commit 338382be79427b8f54d153a7cf32be011da976a9 Author: Deubeuliou Date: Mon Sep 14 12:10:52 2009 +0200 initial export from old svn diff --git a/doxygen/Doxyfile b/doxygen/Doxyfile new file mode 100644 index 0000000..64caad9 --- /dev/null +++ b/doxygen/Doxyfile @@ -0,0 +1,1417 @@ +# Doxyfile 1.5.6 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the config file +# that follow. The default is UTF-8 which is also the encoding used for all +# text before the first occurrence of this tag. Doxygen uses libiconv (or the +# iconv built into libc) for the transcoding. See +# http://www.gnu.org/software/libiconv for the list of possible encodings. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = Olono + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = 0.4 + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = ../doxygen + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create +# 4096 sub-directories (in 2 levels) under the output directory of each output +# format and will distribute the generated files over these directories. +# Enabling this option can be useful when feeding doxygen a huge amount of +# source files, where putting all generated files in the same directory would +# otherwise cause performance problems for the file system. + +CREATE_SUBDIRS = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, +# Croatian, Czech, Danish, Dutch, Farsi, Finnish, French, German, Greek, +# Hungarian, Italian, Japanese, Japanese-en (Japanese with English messages), +# Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, Polish, +# Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish, +# and Ukrainian. + +OUTPUT_LANGUAGE = French + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = NO + +# This tag implements a quasi-intelligent brief description abbreviator +# that is used to form the text in various listings. Each string +# in this list, if found as the leading text of the brief description, will be +# stripped from the text and the result after processing the whole list, is +# used as the annotated text. Otherwise, the brief description is used as-is. +# If left blank, the following values are used ("$name" is automatically +# replaced with the name of the entity): "The $name class" "The $name widget" +# "The $name file" "is" "provides" "specifies" "contains" +# "represents" "a" "an" "the" + +ABBREVIATE_BRIEF = + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = YES + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user-defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the +# path to strip. + +STRIP_FROM_PATH = + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of +# the path mentioned in the documentation of a class, which tells +# the reader which header file to include in order to use a class. +# If left blank only the name of the header file containing the class +# definition is used. Otherwise one should specify the include paths that +# are normally passed to the compiler using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like regular Qt-style comments +# (thus requiring an explicit @brief command for a brief description.) + +JAVADOC_AUTOBRIEF = NO + +# If the QT_AUTOBRIEF tag is set to YES then Doxygen will +# interpret the first line (until the first dot) of a Qt-style +# comment as the brief description. If set to NO, the comments +# will behave just like regular Qt-style comments (thus requiring +# an explicit \brief command for a brief description.) + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen +# treat a multi-line C++ special comment block (i.e. a block of //! or /// +# comments) as a brief description. This used to be the default behaviour. +# The new default is to treat a multi-line C++ comment block as a detailed +# description. Set this tag to YES if you prefer the old behaviour instead. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the DETAILS_AT_TOP tag is set to YES then Doxygen +# will output the detailed description near the top, like JavaDoc. +# If set to NO, the detailed description appears after the member +# documentation. + +DETAILS_AT_TOP = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# re-implements. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce +# a new page for each member. If set to NO, the documentation of a member will +# be part of the file/class/namespace that contains it. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 4 + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user-defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C +# sources only. Doxygen will then generate output that is more tailored for C. +# For instance, some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = YES + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java +# sources only. Doxygen will then generate output that is more tailored for +# Java. For instance, namespaces will be presented as packages, qualified +# scopes will look different, etc. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources only. Doxygen will then generate output that is more tailored for +# Fortran. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for +# VHDL. + +OPTIMIZE_OUTPUT_VHDL = NO + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should +# set this tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. +# func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. + +BUILTIN_STL_SUPPORT = NO + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. +# Doxygen will parse them like normal C++ but will assume all classes use public +# instead of private inheritance when no explicit protection keyword is present. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate getter +# and setter methods for a property. Setting this option to YES (the default) +# will make doxygen to replace the get and set methods by a property in the +# documentation. This will only work if the methods are indeed getting or +# setting a simple type. If this is not the case, or you want to show the +# methods anyway, you should set this option to NO. + +IDL_PROPERTY_SUPPORT = NO + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# Set the SUBGROUPING tag to YES (the default) to allow class member groups of +# the same type (for instance a group of public functions) to be put as a +# subgroup of that type (e.g. under the Public Functions section). Set it to +# NO to prevent subgrouping. Alternatively, this can be done per class using +# the \nosubgrouping command. + +SUBGROUPING = YES + +# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum +# is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically +# be useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. + +TYPEDEF_HIDES_STRUCT = NO + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = NO + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) +# defined locally in source files will be included in the documentation. +# If set to NO only classes defined in header files are included. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. When set to YES local +# methods, which are defined in the implementation section but not in +# the interface are included in the documentation. +# If set to NO (the default) only methods in the interface are included. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base +# name of the file that contains the anonymous namespace. By default +# anonymous namespace are hidden. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these classes will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all +# friend (class|struct|union) declarations. +# If set to NO (the default) these declarations will be included in the +# documentation. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any +# documentation blocks found inside the body of a function. +# If set to NO (the default) these blocks will be appended to the +# function's detailed documentation block. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put a list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the +# brief documentation of file, namespace and class members alphabetically +# by member name. If set to NO (the default) the members will appear in +# declaration order. + +SORT_BRIEF_DOCS = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the +# hierarchy of group names into alphabetical order. If set to NO (the default) +# the group names will appear in their defined order. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be +# sorted by fully-qualified names, including namespaces. If set to +# NO (the default), the class list will be sorted only by class name, +# not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the +# alphabetical list. + +SORT_BY_SCOPE_NAME = NO + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or +# disable (NO) the deprecated list. This list is created by putting +# \deprecated commands in the documentation. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consists of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +# If the sources in your project are distributed over multiple directories +# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy +# in the documentation. The default is NO. + +SHOW_DIRECTORIES = NO + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. +# This will remove the Files entry from the Quick Index and from the +# Folder Tree View (if specified). The default is YES. + +SHOW_FILES = YES + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the +# Namespaces page. This will remove the Namespaces entry from the Quick Index +# and from the Folder Tree View (if specified). The default is YES. + +SHOW_NAMESPACES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command , where is the value of +# the FILE_VERSION_FILTER tag, and is the name of an input file +# provided by doxygen. Whatever the program writes to standard output +# is used as the file version. See the manual for examples. + +FILE_VERSION_FILTER = + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some +# parameters in a documented function, or documenting parameters that +# don't exist or using markup commands wrongly. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be abled to get warnings for +# functions that are documented, but have no documentation for their parameters +# or return value. If set to NO (the default) doxygen will only warn about +# wrong or incomplete parameter documentation, but not about the absence of +# documentation. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. Optionally the format may contain +# $version, which will be replaced by the version of the file (if it could +# be obtained via FILE_VERSION_FILTER) + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is +# also the default input encoding. Doxygen uses libiconv (or the iconv built +# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for +# the list of possible encodings. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank the following patterns are tested: +# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx +# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90 + +FILE_PATTERNS = + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = NO + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used select whether or not files or +# directories that are symbolic links (a Unix filesystem feature) are excluded +# from the input. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. Note that the wildcards are matched +# against the file with absolute path, so to exclude all test directories +# for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. If FILTER_PATTERNS is specified, this tag will be +# ignored. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: +# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further +# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER +# is applied to all files. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse (i.e. when SOURCE_BROWSER is set to YES). + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. +# Note: To get rid of all source code in the generated output, make sure also +# VERBATIM_HEADERS is set to NO. + +SOURCE_BROWSER = YES + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = NO + +# If the REFERENCES_RELATION tag is set to YES +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = NO + +# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) +# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from +# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will +# link to the source code. Otherwise they will link to the documentstion. + +REFERENCES_LINK_SOURCE = YES + +# If the USE_HTAGS tag is set to YES then the references to source code +# will point to the HTML generated by the htags(1) tool instead of doxygen +# built-in source browser. The htags tool is part of GNU's global source +# tagging system (see http://www.gnu.org/software/global/global.html). You +# will need version 4.8.6 or higher. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = NO + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for +# each generated HTML page (for example: .htm,.php,.asp). If it is left blank +# doxygen will generate files with .html extension. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet. Note that doxygen will try to copy +# the style sheet file to the HTML output directory, so don't put your own +# stylesheet in the HTML output directory as well, or it will be erased! + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_DOCSET tag is set to YES, additional index files +# will be generated that can be used as input for Apple's Xcode 3 +# integrated development environment, introduced with OSX 10.5 (Leopard). +# To create a documentation set, doxygen will generate a Makefile in the +# HTML output directory. Running make will produce the docset in that +# directory and running "make install" will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find +# it at startup. + +GENERATE_DOCSET = NO + +# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the +# feed. A documentation feed provides an umbrella under which multiple +# documentation sets from a single provider (such as a company or product suite) +# can be grouped. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that +# should uniquely identify the documentation set bundle. This should be a +# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen +# will append .docset to the name. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. For this to work a browser that supports +# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox +# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari). + +HTML_DYNAMIC_SECTIONS = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can +# be used to specify the file name of the resulting .chm file. You +# can add a path in front of the file if the result should not be +# written to the html output directory. + +CHM_FILE = + +# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can +# be used to specify the location (absolute path including file name) of +# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run +# the HTML help compiler on the generated index.hhp. + +HHC_LOCATION = + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING +# is used to encode HtmlHelp index (hhk), content (hhc) and project file +# content. + +CHM_INDEX_ENCODING = + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the HTML help documentation and to the tree view. + +TOC_EXPAND = NO + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. +# If the tag value is set to FRAME, a side panel will be generated +# containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, +# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are +# probably better off using the HTML help feature. Other possible values +# for this tag are: HIERARCHIES, which will generate the Groups, Directories, +# and Class Hiererachy pages using a tree view instead of an ordered list; +# ALL, which combines the behavior of FRAME and HIERARCHIES; and NONE, which +# disables this behavior completely. For backwards compatibility with previous +# releases of Doxygen, the values YES and NO are equivalent to FRAME and NONE +# respectively. + +GENERATE_TREEVIEW = NONE + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +# Use this tag to change the font size of Latex formulas included +# as images in the HTML documentation. The default is 10. Note that +# when you change the font size after a successful doxygen run you need +# to manually remove any form_*.png images from the HTML output directory +# to force them to be regenerated. + +FORMULA_FONTSIZE = 10 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = YES + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = latex + +# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be +# invoked. If left blank `latex' will be used as the default command name. + +LATEX_CMD_NAME = latex + +# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to +# generate index for LaTeX. If left blank `makeindex' will be used as the +# default command name. + +MAKEINDEX_CMD_NAME = makeindex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = YES + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = YES + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +# If LATEX_HIDE_INDICES is set to YES then doxygen will not +# include the index chapters (such as File Index, Compound Index, etc.) +# in the output. + +LATEX_HIDE_INDICES = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimized for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assignments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. + +GENERATE_XML = NO + +# The XML_OUTPUT tag is used to specify where the XML pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `xml' will be used as the default path. + +XML_OUTPUT = xml + +# The XML_SCHEMA tag can be used to specify an XML schema, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_SCHEMA = + +# The XML_DTD tag can be used to specify an XML DTD, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_DTD = + +# If the XML_PROGRAMLISTING tag is set to YES Doxygen will +# dump the program listings (including syntax highlighting +# and cross-referencing information) to the XML output. Note that +# enabling this will significantly increase the size of the XML output. + +XML_PROGRAMLISTING = YES + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will +# generate an AutoGen Definitions (see autogen.sf.net) file +# that captures the structure of the code including all +# documentation. Note that this feature is still experimental +# and incomplete at the moment. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# configuration options related to the Perl module output +#--------------------------------------------------------------------------- + +# If the GENERATE_PERLMOD tag is set to YES Doxygen will +# generate a Perl module file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_PERLMOD = NO + +# If the PERLMOD_LATEX tag is set to YES Doxygen will generate +# the necessary Makefile rules, Perl scripts and LaTeX code to be able +# to generate PDF and DVI output from the Perl module output. + +PERLMOD_LATEX = NO + +# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be +# nicely formatted so it can be parsed by a human reader. This is useful +# if you want to understand what is going on. On the other hand, if this +# tag is set to NO the size of the Perl module output will be much smaller +# and Perl will parse it just the same. + +PERLMOD_PRETTY = YES + +# The names of the make variables in the generated doxyrules.make file +# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. +# This is useful so different doxyrules.make files included by the same +# Makefile don't overwrite each other's variables. + +PERLMOD_MAKEVAR_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_DEFINED tags. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. To prevent a macro definition from being +# undefined via #undef or recursively expanded use the := operator +# instead of the = operator. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line, have an all uppercase name, and do not end with a semicolon. Such +# function macros are typically used for boiler-plate code, and will confuse +# the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES option can be used to specify one or more tagfiles. +# Optionally an initial location of the external documentation +# can be added for each tagfile. The format of a tag file without +# this location is as follows: +# TAGFILES = file1 file2 ... +# Adding location for the tag files is done as follows: +# TAGFILES = file1=loc1 "file2 = loc2" ... +# where "loc1" and "loc2" can be relative or absolute paths or +# URLs. If a location is present for each tag, the installdox tool +# does not have to be run to correct the links. +# Note that each tag file must have a unique name +# (where the name does NOT include the path) +# If a tag file is not located in the directory in which doxygen +# is run, you must also specify the path to the tagfile here. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed +# in the modules index. If set to NO, only the current project's groups will +# be listed. + +EXTERNAL_GROUPS = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base +# or super classes. Setting the tag to NO turns the diagrams off. Note that +# this option is superseded by the HAVE_DOT option below. This is only a +# fallback. It is recommended to install and use dot, since it yields more +# powerful graphs. + +CLASS_DIAGRAMS = YES + +# You can define message sequence charts within doxygen comments using the \msc +# command. Doxygen will then run the mscgen tool (see +# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the +# documentation. The MSCGEN_PATH tag allows you to specify the directory where +# the mscgen tool resides. If left empty the tool is assumed to be found in the +# default search path. + +MSCGEN_PATH = + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = NO + +# By default doxygen will write a font called FreeSans.ttf to the output +# directory and reference it in all dot files that doxygen generates. This +# font does not include all possible unicode characters however, so when you need +# these (or just want a differently looking font) you can specify the font name +# using DOT_FONTNAME. You need need to make sure dot is able to find the font, +# which can be done by putting it in a standard location or by setting the +# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory +# containing the font. + +DOT_FONTNAME = FreeSans + +# By default doxygen will tell dot to use the output directory to look for the +# FreeSans.ttf font (which doxygen will put there itself). If you specify a +# different font using DOT_FONTNAME you can set the path where dot +# can find it using this tag. + +DOT_FONTPATH = + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for groups, showing the direct groups dependencies + +GROUP_GRAPHS = YES + +# If the UML_LOOK tag is set to YES doxygen will generate inheritance and +# collaboration diagrams in a style similar to the OMG's Unified Modeling +# Language. + +UML_LOOK = NO + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = NO + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = YES + +# If the CALL_GRAPH and HAVE_DOT options are set to YES then +# doxygen will generate a call dependency graph for every global function +# or class method. Note that enabling this option will significantly increase +# the time of a run. So in most cases it will be better to enable call graphs +# for selected functions only using the \callgraph command. + +CALL_GRAPH = NO + +# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then +# doxygen will generate a caller dependency graph for every global function +# or class method. Note that enabling this option will significantly increase +# the time of a run. So in most cases it will be better to enable caller +# graphs for selected functions only using the \callergraph command. + +CALLER_GRAPH = NO + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES +# then doxygen will show the dependencies a directory has on other directories +# in a graphical way. The dependency relations are determined by the #include +# relations between the files in the directories. + +DIRECTORY_GRAPH = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. Possible values are png, jpg, or gif +# If left blank png will be used. + +DOT_IMAGE_FORMAT = png + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found in the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of +# nodes that will be shown in the graph. If the number of nodes in a graph +# becomes larger than this value, doxygen will truncate the graph, which is +# visualized by representing a node as a red box. Note that doxygen if the +# number of direct children of the root node in a graph is already larger than +# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note +# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. + +DOT_GRAPH_MAX_NODES = 50 + +# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the +# graphs generated by dot. A depth value of 3 means that only nodes reachable +# from the root by following a path via at most 3 edges will be shown. Nodes +# that lay further from the root node will be omitted. Note that setting this +# option to 1 or 2 may greatly reduce the computation time needed for large +# code bases. Also note that the size of a graph can be further restricted by +# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. + +MAX_DOT_GRAPH_DEPTH = 0 + +# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent +# background. This is enabled by default, which results in a transparent +# background. Warning: Depending on the platform used, enabling this option +# may lead to badly anti-aliased labels on the edges of a graph (i.e. they +# become hard to read). + +DOT_TRANSPARENT = YES + +# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output +# files in one run (i.e. multiple -o and -T options on the command line). This +# makes dot run faster, but since only newer versions of dot (>1.8.10) +# support this, this feature is disabled by default. + +DOT_MULTI_TARGETS = NO + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermediate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = NO diff --git a/ia/COPYING b/ia/COPYING new file mode 100644 index 0000000..94a9ed0 --- /dev/null +++ b/ia/COPYING @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. 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 +them 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 prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. 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. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey 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; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If 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 convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU 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 that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + 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. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +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. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + 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 +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + 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 3 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, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program 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, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU 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 Lesser General +Public License instead of this License. But first, please read +. diff --git a/ia/Changelog b/ia/Changelog new file mode 100644 index 0000000..0d9f387 --- /dev/null +++ b/ia/Changelog @@ -0,0 +1,12 @@ +Version 0.1 + Written in Python + Quite working referee + +Version 0.2 + Rewritten in C + Working referee + +Version 0.3 + Can finish a match and name the winner + Implementation des arguments + diff --git a/ia/Makefile b/ia/Makefile new file mode 100644 index 0000000..2257a2d --- /dev/null +++ b/ia/Makefile @@ -0,0 +1,49 @@ +OPTS = -g -Wall #-pedantic + +default: all +all: libs olono + +libs: libIA libDisplay libPlay libCases libIA-dumb + +olono:main.o + gcc -o olono main.o ../lib/libCases.so ../lib/libIA.so ../lib/libDisplay.so ../lib/libPlay.so $(OPTS) + gcc -o olono-dumb main.o ../lib/libCases.so ../lib/libIA-dumb.so ../lib/libDisplay.so ../lib/libPlay.so $(OPTS) + +libIA: + gcc -c ../lib/libIA.c -o ../lib/libIA.o $(OPTS) + gcc -o ../lib/libIA.so -shared ../lib/libIA.o $(OPTS) + +libIA-dumb: + gcc -c ../lib/libIA-dumb.c -o ../lib/libIA-dumb.o $(OPTS) + gcc -o ../lib/libIA-dumb.so -shared ../lib/libIA-dumb.o $(OPTS) + +libDisplay: + gcc -c ../lib/libDisplay.c -o ../lib/libDisplay.o $(OPTS) + gcc -o ../lib/libDisplay.so -shared ../lib/libDisplay.o $(OPTS) + +libPlay: + gcc -c ../lib/libPlay.c -o ../lib/libPlay.o $(OPTS) + gcc -o ../lib/libPlay.so -shared ../lib/libPlay.o $(OPTS) + +libCases: + gcc -c ../lib/libCases.c -o ../lib/libCases.o $(OPTS) + gcc -o ../lib/libCases.so -shared ../lib/libCases.o $(OPTS) + +main.o: + gcc -c main.c $(OPTS) + +doc: + doxygen ../doxygen/Doxyfile + $(MAKE) -C ../doxygen/latex -f Makefile + +clean: + rm -v *.o + rm -v ./olono + +mrproper: + rm -v ../lib/*.so + rm -v *.o + rm -v ./olono + rm -v ./olono-dumb + rm -vR ../doxygen/html ../doxygen/latex + diff --git a/ia/Makefile-dumb b/ia/Makefile-dumb new file mode 100644 index 0000000..814473c --- /dev/null +++ b/ia/Makefile-dumb @@ -0,0 +1,45 @@ +OPTS = -g + +default: all +all: libs olono-dumb + +libs: libIA libDisplay libPlay libCases + +olono-dumb:main.o + gcc -o olono-dumb main.o ../lib/libCases.so ../lib/libIA-dumb.so ../lib/libDisplay.so ../lib/libPlay.so $(OPTS) + +libIA: + gcc -c ../lib/libIA-dumb.c -o ../lib/libIA-dumb.o $(OPTS) + gcc -o ../lib/libIA-dumb.so -shared ../lib/libIA-dumb.o $(OPTS) + +libDisplay: + gcc -c ../lib/libDisplay.c -o ../lib/libDisplay.o $(OPTS) + gcc -o ../lib/libDisplay.so -shared ../lib/libDisplay.o $(OPTS) + +libPlay: + gcc -c ../lib/libPlay.c -o ../lib/libPlay.o $(OPTS) + gcc -o ../lib/libPlay.so -shared ../lib/libPlay.o $(OPTS) + +libCases: + gcc -c ../lib/libCases.c -o ../lib/libCases.o $(OPTS) + gcc -o ../lib/libCases.so -shared ../lib/libCases.o $(OPTS) + +main.o: + gcc -c main.c $(OPTS) + +doc: + doxygen ../doxygen/Doxyfile + $(MAKE) -C ../doxygen/latex -f Makefile + +clean: + rm -v *.o + rm -v ./olono-dumb + +mrproper: + rm -v ../lib/libPlay.so ../lib/libPlay.o + rm -v ../lib/libDisplay.so ../lib/libDisplay.o + rm -v ../lib/libIA-dumb.so ../lib/libIA-dumb.o + rm -v *.o + rm -v ./olono-dumb + rm -vR ../doxygen/html ../doxygen/latex + diff --git a/ia/bouchon.c b/ia/bouchon.c new file mode 100644 index 0000000..aa5970b --- /dev/null +++ b/ia/bouchon.c @@ -0,0 +1,523 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +int joueHM(int taille, char * p2, char *log); +int joueMH(int taille, char * p1, char *log); +int joueMM(int taille, char * p1, char * p2, char *log); +int dansGrille(char col ,int lig, int taille); +void finMachineSimple(int from1, char *nom1, int status, int from2, int to2, int pid2, char *nom2, FILE *logFile); +int safeWrite(int fd, char *s); + +int main(int argc, char *argv[]){ + + int taille; + char joueur1, joueur2, trace, rep; + char *path1 = NULL, *path2 = NULL; + char *logFile = NULL; + signal(SIGPIPE,SIG_IGN); /* on ignore les signaux de tube ferme */ + printf("Bonjour\n"); + printf("procedure simplifiee ? (O/N): "); + scanf(" %c",&rep); + if (rep == 'N') { + /* filtre de saisie: taille impaire, entre 5 et 25 */ + do { + printf("Quelle est la taille (impaire) pour la grille ? "); + scanf("%d",&taille); + } while ((taille%2 ==0)||(taille>26)||(taille<4)); + /* filtre de saisie: premier joueur humain ou programme */ + do { + printf("Qui joue les blancs ? Humain ? Machine ? (H/M): "); + scanf(" %c",&joueur1); + } while ((joueur1 != 'H') && (joueur1 != 'M')); + /* filtre de saisie: second joueur humain ou programme */ + do { + printf("Qui joue les noirs ? Humain ? Machine ? (H/M): "); + scanf(" %c",&joueur2); + } while ((joueur2 != 'H') && (joueur2 != 'M')); + + if (joueur1 == 'M'){ + /* le chemin d'acces au programme joueur 1 */ + path1 = malloc(513 * sizeof(char)); + printf("Veuillez entrer le chemin du programme joueur 1: "); + scanf("%s",path1); + while(access(path1,R_OK|X_OK|F_OK) != 0) { + printf("Ce fichier n'existe pas ou bien n'est pas executable\n"); + printf("Veuillez entrer le chemin du programme joueur 1: "); + scanf("%s",path1); + } + } + if (joueur2 == 'M'){ + /* le chemin d'acces au programme joueur 2 */ + + path2 = malloc(513 * sizeof(char)); + printf("Veuillez entrer le chemin du programme joueur 2: "); + scanf("%s",path2); + while(access(path2,R_OK|X_OK|F_OK) != 0) { + printf("Ce fichier n'existe pas ou bien n'est pas executable\n"); + printf("Veuillez entrer le chemin du programme joueur 2: "); + scanf("%s",path2); + } + } + + /* si jamais on veut une trace: non implementee pour l'instant */ + do { + printf("voulez-vous enregistrer la trace d'execution ? (O/N): "); + scanf(" %c",&trace); + } while (trace != 'O' && trace != 'N'); + + if (trace == 'O'){ + logFile = malloc(513 * sizeof(char)); + printf("Veuillez entrer le chemin du fichier de log: "); + scanf("%s",logFile); + } + } else { /* remplissage par defaut */ + joueur1 = 'M'; + joueur2 = 'M'; + taille = 25; + path1 = malloc(30*sizeof(char)); + strcpy(path1,"./olono"); + path2 = malloc(30*sizeof(char)); + strcpy(path2,"./olono-rand"); + logFile = malloc(30*sizeof(char)); + strcpy(logFile,"test"); + } + /* maintenant on a toutes les informations qu'il faut */ + /* pour l'instant, on n'implemente pas le fichier de log */ + int retval; + if ((joueur1 == 'H') && (joueur2 == 'H')){ + printf("Deux joueurs humains, ce n'est pas mon boulot\n"); + } else if((joueur1 == 'H') && (joueur2 == 'M')) { + printf("Humain contre machine (%s), taille %d\n",path2,taille); + retval = joueHM(taille,path2,logFile); + } else if((joueur1 == 'M') && (joueur2 == 'H')) { + printf("Machine (%s) contre humain, taille %d\n",path1,taille); + retval = joueMH(taille,path1,logFile); + } else { + printf("Machine (%s) contre machine (%s)\n",path1,path2); + retval = joueMM(taille,path1,path2,logFile); + } + + + printf("\n\nLe jeu est termine ! \n\n"); + free(path1); + free(path2); + free(logFile); + return retval; +} + +int dansGrille(char col, int lig, int taille){ +return (((col -'A') >= 0) && ((col - 'A') < taille) && + (lig >= 0) && (lig < taille)); +} + + +/* jeu d'un homme contre une machine */ +int joueHM(int taille, char *p2, char *log){ + int versProgramme[2]; /* tube pour envoyer des infos VERS le programme */ + int deProgramme[2]; /* tube pour recuperer des infos DEPUIS le programme */ + FILE *logFile = NULL; + if (log != NULL){ + printf("fichier d'enregistrement: %s\n",log); + logFile = fopen(log,"w"); + } + pipe(versProgramme); + pipe(deProgramme); + int pid = fork(); + if (pid == -1){ + perror("Fork n'a pas reussi\n"); + return(-1); + } else if (pid == 0){ + /* on est l'enfant: lancer le programme apres avoir + * redirige entree et sortie standard vers les tubes */ + dup2(versProgramme[0],STDIN_FILENO); + dup2(deProgramme[1],STDOUT_FILENO); + close(versProgramme[1]); // pas besoin de lire ce qu'on ecrit + close(deProgramme[0]); // et inversement + char t[40]; + sprintf(t,"%d",taille); + execlp(p2,p2,t,"grilleOn","ia","N",(char *) NULL); + perror("Pas reussi a executer le programme. Desole"); + free(p2); + exit(-4); + } else { + /* on est le pere et pid est le pid du fils */ + /* on recupere les infos du tube. On veut bien sur aussi + * garder entree et sortie standard */ + close(versProgramme[0]); + close(deProgramme[1]); + printf("Vous etes les blancs, vous commencez\n"); + char *coupBlanc = malloc(513 * sizeof(char)); + char *coupNoir = malloc(513 * sizeof(char)); + coupNoir[512] = '\0'; + char colonneB, colonneN; + int ligneB, ligneN; + int nbRead; + int status; + int changed; + do { + changed = waitpid(pid,&status,WNOHANG); // on regarde si le fils n'a pas termine + if (changed == 0) { + do { + printf("Votre coup (blancs) : "); + scanf("%s",coupBlanc); + colonneB = coupBlanc[0]; + sscanf(coupBlanc+1,"%d",&ligneB); + } while (dansGrille(colonneB,ligneB,taille) == 0); + printf("Vous jouez le coup: %s\n",coupBlanc); + write(versProgramme[1],coupBlanc,strlen(coupBlanc)); + if (logFile != NULL){ + fprintf(logFile,coupBlanc); + fflush(logFile); + } + /* attente bloquante */ + nbRead = read(deProgramme[0],coupNoir,512); + printf("Lu %d caracteres\n",nbRead); + if (nbRead >= 5){ + printf("Les noirs declarent %s\n",coupNoir); + } else { /* un coup legal */ + printf("Les noirs jouent %s\n",coupNoir); + } + if (logFile != NULL){ + fprintf(logFile,coupNoir); + fflush(logFile); + } + } else { + printf("Les noirs ont termine de jouer: %d\n",WEXITSTATUS(status)); + } + } while (changed == 0); + /* on continue tant que le fils n'a pas termine */ + /* puis on libere tout */ + free(coupNoir); + free(coupBlanc); + close(versProgramme[1]); + close(deProgramme[0]); + return 0; + } +} + + +/* jeu d'une machine contre un homme */ +int joueMH(int taille, char *p1, char *log){ + int versProgramme[2]; /* tube pour envoyer des infos VERS le programme */ + int deProgramme[2]; /* tube pour recuperer des infos DEPUIS le programme */ + FILE *logFile = NULL; + if (log != NULL){ + printf("fichier d'enregistrement: %s\n",log); + logFile = fopen(log,"w"); + } + pipe(versProgramme); + pipe(deProgramme); + int pid = fork(); + if (pid == -1){ + perror("Fork n'a pas reussi\n"); + return(-1); + } else if (pid == 0){ + /* on est l'enfant: lancer le programme apres avoir + * redirige entree et sortie standard vers les tubes */ + dup2(versProgramme[0],STDIN_FILENO); + dup2(deProgramme[1],STDOUT_FILENO); + close(versProgramme[1]); // pas besoin d ecrire ce qu'on lit + close(deProgramme[0]); // et inversement + char t[40]; + sprintf(t,"%d",taille); + execlp(p1,p1,t,"grilleOn","ia","B",(char *) NULL); + perror("Pas reussi a executer le programme. Desole"); + free(p1); + exit(-4); + } else { + /* on est le pere et pid est le pid du fils */ + /* on recupere les infos du tube. On veut bien sur aussi + * garder entree et sortie standard */ + close(versProgramme[0]); + close(deProgramme[1]); + printf("Vous etes les noirs, vous jouez en second\n"); + char *coupBlanc = malloc(513 * sizeof(char)); + char *coupNoir = malloc(513 * sizeof(char)); + coupBlanc[512] = '\0'; + char colonneB, colonneN; + int ligneB, ligneN; + int nbRead; + int status; + int changed; + do { + changed = waitpid(pid,&status,WNOHANG); // on regarde si le fils n'a pas termine + if (changed == 0) { + /* attente bloquante ??? */ + nbRead = read(deProgramme[0],coupBlanc,512*sizeof(char)); + if (nbRead >= 5){ + printf("Les blancs declarent: %s",coupBlanc); + } else { /* un coup legal */ + printf("Les blancs jouent: %s",coupBlanc); + } + if (logFile != NULL){ + fprintf(logFile,coupBlanc); + fflush(logFile); + } + changed = waitpid(pid,&status,WNOHANG); // on teste encore une fois le fils + if (changed == 0) { + do { + printf("Votre coup (noirs) : "); + scanf("%s",coupNoir); + colonneN = coupNoir[0]; + sscanf(coupNoir+1,"%d",&ligneN); + } while (dansGrille(colonneN,ligneN,taille) == 0); + printf("Vous jouez le coup: %s\n",coupNoir); + write(versProgramme[1],coupNoir,strlen(coupNoir)); + if (logFile != NULL){ + fprintf(logFile,coupNoir); + fflush(logFile); + } + } + } else { + printf("Les blancs ont termine de jouer: %d\n",WEXITSTATUS(status)); + } + } while (changed == 0); + /* on continue tant que les blancs n'ont pas termine */ + /* puis on libere tout */ + free(coupNoir); + free(coupBlanc); + close(versProgramme[1]); + close(deProgramme[0]); + return 0; + } +} + +int joueMM(int taille, char *p1, char *p2, char *log){ + FILE *logFile = NULL; + if (log != NULL){ + printf("fichier d'enregistrement: %s\n",log); + logFile = fopen(log,"w"); + } + int versProgrammeA[2], versProgrammeB[2]; + int deProgrammeA[2], deProgrammeB[2]; + pipe(versProgrammeA); + pipe(deProgrammeA); + int pidA = fork(); + if (pidA == -1){ + perror("Fork n'a pas reussi"); + return(-1); + } else if (pidA == 0){ + /* fils A: les blancs */ + dup2(versProgrammeA[0],STDIN_FILENO); + dup2(deProgrammeA[1],STDOUT_FILENO); + close(versProgrammeA[1]); + close(deProgrammeA[0]); + fclose(logFile); + char t[40]; + sprintf(t,"%d",taille); + execlp(p1,p1,t,"grilleOn","ia","B",(char *) NULL); + perror("Pas reussi a executer le programme A. Desole"); + return -4; + + } else { + /* pere */ + pipe(versProgrammeB); + pipe(deProgrammeB); + close(versProgrammeA[0]); + close(deProgrammeA[1]); + int pidB = fork(); + if (pidB == -1){ + perror("Fork 2 n'a pas reussi"); + return -1; /* le fils A est tue quand le pere meurt */ + } else if (pidB == 0) { + + /* fils B: les noirs */ + close(versProgrammeA[1]); + close(deProgrammeA[0]); + close(versProgrammeB[1]); + close(deProgrammeB[0]); + fclose(logFile); + dup2(versProgrammeB[0],STDIN_FILENO); + dup2(deProgrammeB[1],STDOUT_FILENO); + char t[40]; + sprintf(t,"%d",taille); + execlp(p2,p2,t,"grilleOff","ia","N",(char *) NULL); + perror("Pas reussi a executer le programme B. Desole"); + return -5; + + } else { + /* le pere */ + close(versProgrammeB[0]); + close(deProgrammeB[1]); + char *coupBlanc = malloc(513 * sizeof(char)); + char *coupNoir = malloc(513 * sizeof(char)); + int nbRead; + int status; + int changed; + int i=0; + do { + changed = waitpid(pidA,&status,WNOHANG); + if (changed == 0) { + nbRead = read(deProgrammeA[0],coupBlanc,512); + coupBlanc[nbRead] = '\0'; + if (nbRead >= 5){ + printf("Les blancs declarent: %s",coupBlanc); + } else { /* un coup legal: colonne, ligne, \n et \0 */ + printf("Les blancs jouent: %s",coupBlanc); + } + safeWrite(versProgrammeB[1],coupBlanc); + if (logFile != NULL){ + fprintf(logFile,coupBlanc); + fflush(logFile); + } + changed = waitpid(pidB,&status,WNOHANG); + if (changed == 0){ + nbRead = read(deProgrammeB[0],coupNoir,512); + coupNoir[nbRead] = '\0'; + if (nbRead >= 5){ + printf("Les noirs declarent: %s",coupNoir); + } else { /* un coup legal: colonne, ligne, \n et \0 */ + printf("Les noirs jouent: %s",coupNoir); + } + /* tester si on peut ecrire avant de le faire ! Sinon ca plante */ + safeWrite(versProgrammeA[1],coupNoir); + if (logFile != NULL){ + fprintf(logFile,coupNoir); + fflush(logFile); + } + } else { + finMachineSimple(deProgrammeB[0],"noirs",status,deProgrammeA[0],versProgrammeA[1],pidA,"blancs",logFile); + } + } else { + finMachineSimple(deProgrammeA[0],"blancs",status,deProgrammeB[0],versProgrammeB[1],pidB,"noirs",logFile); + } + } while (changed == 0); + free(coupNoir); + free(coupBlanc); + if (logFile != NULL){ + fprintf(logFile,"\n---- partie terminee ----\n "); + fflush(logFile); + fclose(logFile); + } + close(versProgrammeA[1]); + close(deProgrammeA[0]); + close(versProgrammeB[1]); + close(deProgrammeB[0]); + return 0; + } // fin second fork + } // fin premier fork + +} + + +void finMachineSimple(int from1, char *nom1, int status, int from2, int to2, int pid2, char *nom2, FILE *logFile){ + int nbRead; + char *coup1 = malloc(513 * sizeof(char)); + char *coup2 = malloc(513 * sizeof(char)); + struct rusage infoFils; + double uFils1, sFils1, uFils2, sFils2; + printf("Les %s ont termine de jouer: %d!\n",nom1,WEXITSTATUS(status)); + getrusage(RUSAGE_CHILDREN,&infoFils); + /* on recupere des secondes et des micro secondes pour le temps CPU passe + * en calculs utilisateurs et en appel de fonctions systeme du fils 1 */ + sFils1 = ((double) infoFils.ru_stime.tv_sec) + ((double) infoFils.ru_stime.tv_usec)/1000000; + uFils1 = ((double) infoFils.ru_utime.tv_sec) + ((double) infoFils.ru_utime.tv_usec)/1000000; + printf("Les %s ont utilise %lf sec de systeme et %lf de temps utilisateur\n", + nom1,sFils1,uFils1); + nbRead = read(from1,coup1,512); + if (nbRead > 0){ + coup1[nbRead] = '\0'; + printf("Les %s ont un dernier message: %s",nom1,coup1); + safeWrite(to2,coup1); + if (logFile != NULL){ + fprintf(logFile,coup1); + fflush(logFile); + } + } + sleep(1); /* on attend une seconde que l'autre ait aussi termine ! */ + if (waitpid(pid2,&status,WNOHANG) == 0){ + printf("Cependant, les %s n'ont pas termine de jouer ... tant pis.\n",nom2); + /* on les tue */ + kill(pid2,SIGKILL); + waitpid(pid2,&status,WNOHANG); + } else { + printf("Les %s on aussi termine: %d!\n",nom2,WEXITSTATUS(status)); + } + getrusage(RUSAGE_CHILDREN,&infoFils); + /* idem, sauf qu'on recupere la somme du fils 1 et du fils 2 ... */ + sFils2 = ((double) infoFils.ru_stime.tv_sec) + ((double) infoFils.ru_stime.tv_usec)/1000000; + uFils2 = ((double) infoFils.ru_utime.tv_sec) + ((double) infoFils.ru_utime.tv_usec)/1000000; + /* idem, sauf qu'on recupere la somme du fils 1 et du fils 2 */ + sFils2 = sFils2 - sFils1; + uFils2 = uFils2 - uFils1; + printf("Les %s ont utilise %lf sec de systeme et %lf de temps utilisateur\n", + nom2,sFils2,uFils2); + nbRead = read(from2,coup2,512); + if(nbRead > 0){ + coup2[nbRead] = '\0'; + printf("Les %s ont un dernier message: %s",nom2,coup2); + if (logFile != NULL){ + fprintf(logFile,coup2); + fflush(logFile); + } + } +} + +/* ecrit de facon "sure" dans un tube: si on essaie d'ecrire dans un tube * + * ferme, on recoit un signal qui fait terminer le programme */ +/* retourne le nombre de caracteres ecrit et -1 si ca s'est mal passe */ +int safeWrite(int fd, char *s){ + if (write(fd,s,strlen(s)) == -1) + printf("Impossible d'ecrire dans le tube: il est ferme en lecture\n"); + return 0; +} + + + + + +/* vieux machin complique et qui marche pas + +void finMachine(int from1, char *nom1, int status, int from2, int to2, int pid2, char *nom2, FILE *logFile){ + int nbRead; + fd_set set; + struct timeval timeout = {1,0};// timeout a 1 seconde + char *coup1 = malloc(513 * sizeof(char)); + char *coup2 = malloc(513 * sizeof(char)); + printf("Les %s ont termine de jouer: %d!\n",nom1,WEXITSTATUS(status)); + FD_ZERO(&set); + FD_SET(from1,&set); + // s'il y a encore des choses a lire + if (select(from1+1,&set,NULL,NULL,&timeout) == 0){ + printf("Les %s n'ont rien d'autre a ajouter\n",nom1); + } else { + nbRead = read(from1,coup1,512); + coup1[nbRead] = '\0'; + printf("Les %s ont un dernier message: %s",nom1,coup1); + safeWrite(to2,coup1); + if (logFile != NULL){ + fprintf(logFile,coup1); + fflush(logFile); + } + } + if (waitpid(pid2,&status,WNOHANG) == 0){ + printf("Cependant, les %s n'ont pas termine de jouer ... tant pis.\n",nom2); + } else { + printf("Les %s on aussi termine: %d!\n",nom2,WEXITSTATUS(status)); + } + FD_ZERO(&set); + FD_SET(from2,&set); + if (select(from2+1,&set,NULL,NULL,&timeout) == 0){ + printf("Les %s n'ont rien a dire\n",nom2); + } else { + nbRead = read(from2,coup2,512); + coup2[nbRead] = '\0'; + printf("Les %s ont un dernier message: %s",nom2,coup2); + if (logFile != NULL){ + fprintf(logFile,coup2); + fflush(logFile); + } + } + +} +*/ + diff --git a/ia/fakeMachine.c b/ia/fakeMachine.c new file mode 100644 index 0000000..e581f07 --- /dev/null +++ b/ia/fakeMachine.c @@ -0,0 +1,110 @@ +#include +#include +#include +#include +#include +#include +#include + + +long ack(long n, long m); + +int main(int argc, char *argv[]) +{ + + /* des messages d'erreur si on a mal lance le programme */ + + char *errmsg = malloc(257 * sizeof(char)); + if (argc < 5) + { + perror("Il faut 4 arguments:\n 1: taille de la grille\n2: affichage de la grille\n3: humain/ia\n4: B/N\n"); + free(errmsg); + return -1; + } + + char *hum = argv[3]; /* 3e argument: humain/ia */ + char *bw = argv[4]; /* 4eme argument: Blancs/Noirs */ + if ((strncmp(hum,"ia",2) != 0) || (bw[0] != 'N' && bw[0] != 'B')) + { + snprintf(errmsg,256,"Mauvais format de l'argument \"%s\" ou \"%s\"\n",hum,bw); + perror(errmsg); + return -2; + } + + /* fin des messages d'erreurs */ + + /**********************/ + /* CORPS DU PROGRAMME */ + /**********************/ + + int i; + int nbOctetsLus; + char * input = malloc(256 * sizeof(char)); /* buffer d'entree */ + char * output = malloc(256 * sizeof(char)); /* coup joue: maximum 4 caracteres */ + + if (bw[0] == 'B') { + + /* joue les blancs: 10 fois le meme coup */ + for (i=0;i<10;i++){ + /* joue un coup: ecrit son coup, identique a printf("A1\n"); */ + strcpy(output,"A1\n"); + write(STDOUT_FILENO,output,strlen(output)); + /* lit le coup joue, identique a scanf("%s",input) */ + nbOctetsLus = read(STDIN_FILENO,input,255); + input[nbOctetsLus] = '\0'; // tableau de caracteres => chaine avec \0 a la fin + /* on recommence */ + } + snprintf(output,255,"Les blancs (moi) ont gagne ! Score: 30(B) - 15(N)\n"); + write(STDOUT_FILENO,output,strlen(output)); + + /*************************************************************************** + * remarques sur l'utilisation de write: le 2nd argument est ce qu'on veut * + * ecrire et le 3eme est le nb d'octets ecrire. Pour plus d'informations * + * man 2 write.Pour read: le 2d argument est l'adresse du buffer (alloue !)* + * et le 3eme est le bf d'octets maximum que l'on veut lire (en general: * + * la taille en octets du buffer. Pour plus d'information, voir man read * + * enfin, dans les deux cas, le premier argument est la source (ou la * + * destination), en l'occurrence, l'entree et la sortie standard. * + /***************************************************************************/ + + } + + else if (bw[0] == 'N') + { + + + /* joue les noirs: 10 fois le meme coup */ + for (i=0;i<10;i++){ + nbOctetsLus = read(STDIN_FILENO,input,255); + input[nbOctetsLus] = '\0'; + strcpy(output,"B1\n"); + write(STDOUT_FILENO,output,strlen(output)); + } + snprintf(output,255,"Les noirs (moi) ont gagne ! Score: 15(B) - 35(N)\n"); + write(STDOUT_FILENO,output,strlen(output)); + } + + /*****************************/ + /* FIN DU CORPS DU PROGRAMME */ + /*****************************/ + + free(errmsg); + free(input); + free(output); + return 0; +} + + + +/* la celebre fonction d'Ackermann: impossible a calculer ne serait-ce que + * ack(5,5). Prend un temps hyperexponentiel */ + long ack(long n, long m){ + if (n == 0) + return m + 1; + if (m == 0) + return ack(n-1,1); + else { + return ack(n-1,ack(n,m-1)); + } + + } diff --git a/ia/main.c b/ia/main.c new file mode 100644 index 0000000..836d6d6 --- /dev/null +++ b/ia/main.c @@ -0,0 +1,191 @@ +/* This file is part of OloNO + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * main.c + * Contient la boucle principale du programme + */ + +#include +#include +#include +#include + +// On inclu nos librairies personnelles : +#include "../lib/libDefine.h" +#include "../lib/libDisplay.h" +#include "../lib/libPlay.h" +#include "../lib/libCases.h" +#include "../lib/libIA.h" + +int boucleDeJeu(CASE *plateau[]); + +// Certains compilos définissent _WIN32, d'autres __WIN32 +#ifdef _WIN32 +#ifndef __WIN32 +#define __WIN32 +#endif +#endif + +// Variables globales +arguments args; +int taillePlateau; // Taille du plateau par défaut; + +//! Lance le programme +/** + * Cette fonction est la boucle principale du programme. + * Elle permet de rassembler toutes les autres fonctions dans un contenu reflétant + * le fonctionnement du programme. Pour comprendre le fonctionnement d'un programme, + * lire le main() devrait suffire. +*/ +int main(int argc, char ** argv) +{ + + if (argc < 5) + return 1; + + /* On initialise les arguments à leur valeur par défaut */ + args.taillePlateau = atoi(argv[1]); + args.verbose = (strcmp("grilleOn", argv[2]) == 0) ? 1 : 0; + strcpy(args.type, argv[3]); + args.couleur = (*argv[4] == 'B' ? 0 : 1); + args.Tore = 0; + + taillePlateau = args.taillePlateau; + +// erreur("valeur d'un coin:%d\n", valeurLigne(0)+valeurLigne(0)); +// erreur("valeur en diagonale d'un coin:%d\n", valeurLigne(1)+valeurLigne(1)); +// erreur("idem, mais a la fin:%d\n", valeurLigne(taillePlateau-2)+valeurLigne(taillePlateau-2)); +// erreur("valeur d'un pion a coté du joker:%d\n", valeurLigne(taillePlateau/2 - 1)*valeurLigne(taillePlateau/2 + 1)); + +// ############################################################### // +// ### On commence les choses sérieuses ici (cad le main) ######## // +// ############################################################### // + + int i=0; // Variables de boucle. + int points[]={0, 0}; // Points obtenus pour les blancs et les noirs + char retour; + +// ######################################################################################### // +// # ETAPE 2 : Initialiser le plateau ###################################################### // +// ######################################################################################### // + + // On créé un tableau à la taille demandée par le joueur + CASE ** plateau = createPlateau(); + // On initialise ce tableau avec la consigne + initPlateau(plateau); + +// ######################################################################################### // +// # ETAPE 3 : Boucle de jeux principale ################################################### // +// ######################################################################################### // + + retour = boucleDeJeu(plateau); + + if (retour) + erreur("La boucle de jeu s'est arrêtée à cause d'une erreur\n"); + +// ######################################################################################### // +// # ETAPE 4 : Score ####################################################################### // +// ######################################################################################### // + + affichePlateau(plateau); + score(plateau, points); + afficherScore(points); + + // On oublie pas de libérer l'espace mallocé + for (i=0; i) and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include +#include "libDefine.h" +#include "libCases.h" + +extern arguments args; +extern int taillePlateau; + +//! retourne l'adresse de la case (x, y) +/** + * En plus de retourner un pointeur sur la case (x,y), elle peut permettre de + * vérifier la validité des coordonnées (retourne NULL si la case est hors du + * plateau.) + */ +CASE * adresseParXY(int x, int y, CASE *plateau[]) +{ + if (x>=taillePlateau || y>=taillePlateau + || x<0 || y<0) + return NULL; + + return plateau[x*taillePlateau + y]; +} + +//! Renvoie un pointeur sur la case suivante selon un vecteur +/** + * Prend une case et un vecteur en argument, ainsi que la taille du plateau et + * la liste des cases. Renvoie l'adresse de la case suivante sur ce vecteur + */ +CASE * caseSuivante(CASE depart, int incX, int incY, CASE *plateau[]) +{ + int x, y; + + // Si on arrive au bout du plateau (depart.x+incX = taillePlateau), on + // repart à 0. idem pour y + x = depart.x + incX; + if (x == taillePlateau) + { + if (args.Tore) + x = 0; + else + return NULL; + } + else if (x == -1) + { + if (args.Tore) + x = taillePlateau-1; + else + return NULL; + } + + y = depart.y + incY; + if (y == taillePlateau) + { + if (args.Tore) + y = 0; + else + return NULL; + } + else if (y == -1) + { + if (args.Tore) + y = taillePlateau-1; + else + return NULL; + } + + return adresseParXY(x, y, plateau); +} diff --git a/lib/libCases.h b/lib/libCases.h new file mode 100644 index 0000000..627aa53 --- /dev/null +++ b/lib/libCases.h @@ -0,0 +1,51 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// Comme certaines librairies incluent cette lib et des libs qui l'incluent +// aussi, il ne faut le lire qu'une fois +#ifndef _LIB_CASES_H +#define _LIB_CASES_H + +#include "libDefine.h" + +//! Structure de case. +typedef struct _CASE +{ + char couleur; /**< Couleur de la case */ + int x, y; +} CASE; + +typedef struct _NOEUD +{ + int nbDeFils; + struct _NOEUD ** listeFils; // liste des pointeurs sur les fils (de taille nbDeFils) + struct _CASE ** plateau; + char x, y; + char valeur; + char couleur; + char meilleurX; + char meilleurY; + struct _NOEUD * pere; +} NOEUD; + +CASE * adresseParXY(int x, int y, CASE *plateau[]); +CASE * caseSuivante(CASE depart, int incX, int incY, CASE *plateau[]); +#endif + diff --git a/lib/libDefine.h b/lib/libDefine.h new file mode 100644 index 0000000..cb4105c --- /dev/null +++ b/lib/libDefine.h @@ -0,0 +1,64 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libDefine.h + * Contient des macros et des structures pour tout le programme. + * Elles définissent les valeurs d'int associées aux 4 types de cases. De la + * même manière est définit la taille d'un plateau par défaut. + */ + +#ifndef _LIB_DEFINE_H +#define _LIB_DEFINE_H + +#define VIDE 3 +#define BLANC 0 +#define NOIR 1 +#define JOKER 2 + +#define INFINI 0x7FFFFFFF // 2^31 + +#define abs(X) ((X) > 0 ? (X) : -(X)) +#define max(X, Y) ((X) > (Y) ? (X) : (Y)) +#define min(X, Y) ((X) < (Y) ? (X) : (Y)) + +#define proportion(X, Y) ((X)) / ((X)+(Y)) + +/* This structure is used by main to communicate with parse_opt. */ +typedef struct _arguments +{ + int taillePlateau; /* Arguments for -t */ + char verbose; /* 1 si on doit aficher la grille, 0 sinon */ + char type[7]; /* humain ou ia */ + char couleur; /* 'N' ou 'B' */ + int Tore; /* Arguments for -T */ +} arguments; + +typedef struct _preferences +{ + int couleurDepart; + int allowIA; + int couleurIA; + int affJouable; + int taillePlateau; +} preferences; + +#endif + diff --git a/lib/libDisplay.c b/lib/libDisplay.c new file mode 100644 index 0000000..f34c902 --- /dev/null +++ b/lib/libDisplay.c @@ -0,0 +1,281 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libDisplay.c (console) + * Contient les fonctions d'affichage en mode console: + * concerne aussi bien l'affichage de la grille que les entrées utilisateur. + */ + +#include +#include +#include +#include +#include +#include +#include "libDefine.h" +#include "libPlay.h" +#include "libDisplay.h" + +int taillePlateau; + +//! Demande les coordonnées au joueur +/** + * Cette fonction demande à l'utilisateur les coordonnées du point à jouer + * et les converti pour qu'elles correspondent aux indices en mémoire. +*/ +char demanderAction(char couleur) +{ + char retourScanf = '\0'; + + do + { + ecrire("%s, que voulez-vous faire: (J)ouer ou (R)eculer dans l'historique ? ", + (couleur == BLANC) ? "Blanc" : "Noir"); + scanf(" %c%*[^\n]", &retourScanf); // On scan un char puis n'importe quoi sauf un retour à la ligne + + int c; + // ... On vide le flux + while ( ((c = getchar()) != '\n') && c != EOF); + } + while (retourScanf != 'J' && retourScanf != 'R'); + + return retourScanf; +} + +//! Demande les coordonnées au joueur +/** + * Cette fonction demande à l'utilisateur les coordonnées du point à jouer + * et les converti pour qu'elles correspondent aux indices en mémoire. +*/ +void demanderXY(int coords[]) +{ + char x=0; + int y=0; + + do + { + printf("Entrez les coordonnées où jouer: "); + scanf(" %c%d%*[^\n]", &x, &y); // On scan un char puis un int puis n'importe quoi sauf un retour à la ligne + x = toupper(x); + + int c; + // ... On vide le flux + while ( ((c = getchar()) != '\n') && c != EOF); + } + while (!( x>='A' && (x-'A')=0 && ycouleur]); + } + erreur("\n"); // après chaque ligne, retour à la ligne + } + erreur(" "); + for (i=0;i 25)) + { + printf("Entrez une taille entre 4 et 25 : "); + retourScanf = scanf("%d%*[^\n]",&taillePlateau); + // Si le scanf a retourné une erreur ... + if (!retourScanf) + { + // ... On vide le flux + char c; + while ( ((c = getchar()) != '\n') && c != EOF); + } + else + // Si tout s'est bien passé, on enlève le \n final + getchar(); + } + + return taillePlateau; +} + +//! Dire bonjour : +void direBonjour() +{ +ecrire("\tOloNO Copyright (C) 2008 David Wagner && Martin Potier\n\ +\tThis program comes with ABSOLUTELY NO WARRANTY;\n\ +\tThis is free software, and you are welcome to redistribute it under\n\ +\tcertain conditions\n\n"); +ecrire("Bienvenue à OloNO\nOloNO is not an othello\n\n"); +} + +//! utilise ecrire() pour envoyer les coordonnées +void envoyerXY(int x, int y) +{ + ecrire("%c%d\n", x + 'A', taillePlateau - y - 1); +} + +//! utilise ecrire() pour signifier qu'il n'y a pas de coup possible +void pasDeCoup() +{ + write(STDOUT_FILENO, "pas de coup\n", 12); +} + +//! lit un coup sur stdin +/** + * Si "pas de coup" est reçu, on renvoit 1. + * Sinon, on renvoie 0 et on place les coordonnées dans x et y + * Cette fonction ne se charge pas de vérifier que les coordonnées soient + * bonnes: ele est utilisée par l'IA, qui doit s'arrêter en cas d'erreur de + * l'adversaire + */ +int lireCoup(char * x, int * y) +{ + char * input = malloc(20 * sizeof(char)); + char * copie = malloc(20 * sizeof(char)); + + read(STDIN_FILENO, input, 20); + + int i=0; + while((copie[i] = input[i]) && copie[i++] != '\n'); + copie[i] = '\0'; + free(input); + + if (strcmp(copie, "pas de coup\n") == 0) + { + free(copie); + return 1; // L'adversaire ne peut pas jouer + } + + sscanf(copie, "%c%d", x, y); + *x = (int) toupper(*x) - 'A'; + *y = taillePlateau - *y - 1; + + free(copie); + return 0; +} + +//! Affiche le score +/** + * Utilise l'erreur standard pour ne pas encombrer la stdin qui ne doit + * concerner que les coups joués + */ +void afficherScore(int points[]) +{ + if (points[0] > points[1]) + erreur("Les blancs gagnent par %d à %d\n", points[0], points[1]); + else if (points[1] > points[0]) + erreur("Les noirs gagnent par %d à %d\n", points[1], points[0]); + else + erreur("Partie nulle: %d partout\n", points[0]); +} + diff --git a/lib/libDisplay.h b/lib/libDisplay.h new file mode 100644 index 0000000..18ec4d5 --- /dev/null +++ b/lib/libDisplay.h @@ -0,0 +1,47 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libDisplay.h + * Prototypes de libDisplay.c + */ + +#ifndef _LIB_DISPLAY_H +#define _LIB_DISPLAY_H + +#include "libCases.h" + +extern int taillePlateau; + +char demanderAction(char couleur); +void demanderXY(int coords[]); +void affichePlateau(CASE *plateau[]); +void direBonjour(); +void demanderXY(int coords[]); +void ecrire(char *chaine, ...); +void erreur(char *chaine, ...); +int demanderTaillePlateau(); +void envoyerXY(int x, int y); +void pasDeCoup(); +int lireCoup(char * x, int * y); +void afficherScore(int points[]); + +#endif + diff --git a/lib/libIA-dumb.c b/lib/libIA-dumb.c new file mode 100644 index 0000000..44cfed5 --- /dev/null +++ b/lib/libIA-dumb.c @@ -0,0 +1,162 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include +#include +#include "libDefine.h" +#include "libIA.h" +#include "libPlay.h" +#include "libDisplay.h" // Pour les messages de debug + +extern int taillePlateau; +extern arguments args; + +//! Place les meilleures coordonnées dans x et y +int meilleurXY(CASE *plateau[], char couleur, int * x, int * y) +{ + NOEUD noeud; // On crée le noeud-père + noeud.couleur = !couleur; // C'est l'adversaire qui vient de jouer + + // On récupère ici la valeur du plateau. + // On ne s'en sert actuellement pas mais bon... + int valeur = minmax(plateau, &noeud, 6, -INFINI, INFINI); + if (args.verbose) + erreur("Veleur supposée du coup: %d\n", valeur); + + // On récupère les coordonnées du meilleur coup directement fils + *x = noeud.meilleurX; + *y = noeud.meilleurY; + + return 0; +} + +//! Calcule l'arbre des possibilités et renvoie la valeur du noeud en cours +/** + * Implémentation de l'algorithme Minimax + * S'appelle récursivement pour calculer la valeur d'un noeud à partir des + * noeuds fils. + * Si un noeud est terminal, sa valeur est sa valeur heuristique (pour le + * moment, c'est tout simplement le différentiel de score. Il n'y a pas de + * fonction heuristique). Sinon, elle est égale à la plus basse valeur des + * fils. (Grâce à la simplification Negamax, pas besoin d'alterner entre plus + * bas et plus haut selon qu'on est sur un noeud ennemi ou allié). + * A venir: heuristique; élagage + */ +int minmax(CASE *plateau[], NOEUD * noeud, int profondeur, int alpha, int beta) +{ + if (profondeur <= 0) // Si on est un noeud terminal on renvoie la valeur du plateau + { + int points[] = {0, 0}; + score(plateau, points); // Pour le moment, il n'y a pas de fonction heuristique, on prend le score brut + return points[(int) noeud->couleur] - points[(int) !(noeud->couleur)]; // Valeur du noeud; + } + + int index; + int i, j; + int * listeValides = malloc(taillePlateau * taillePlateau * sizeof(int)); + + // On calcule le nombre de fils et on alloue la liste des fils en + // onséquence. + noeud->nbDeFils = nbCoupsValides(!(noeud->couleur), plateau, listeValides); + //if (noeud->nbDeFils > 2) + // noeud->nbDeFils = 2; + if (noeud->nbDeFils) + noeud->listeFils = calloc(noeud->nbDeFils, sizeof(NOEUD *)); // calloc met la mémoire à 0 + else + noeud->listeFils = malloc(1*sizeof(NOEUD)); // Si le joueur ne peut pas jouer, il passe: 1 noeud + + for(i=0; i<(noeud->nbDeFils); i++) + { + // On alloue le noeud fils + (noeud->listeFils)[i] = malloc(sizeof(NOEUD)); + NOEUD * fils = (noeud->listeFils)[i]; + fils->listeFils = NULL; + fils->nbDeFils = 0; + + // On crée une copie de travail du plateau + // (Très consommateur de mémoire) + fils->plateau = copiePlateau(plateau); + + // On calcule ses coordonnées + fils->x = listeValides[i]/taillePlateau; + fils->y = listeValides[i]%taillePlateau; + fils->couleur = !(noeud->couleur); + + // On simule le coup sur la copie + jouerCoup(fils->x, fils->y, fils->couleur, fils->plateau); + + // Convention Negamax + fils->valeur = -minmax(fils->plateau, fils, profondeur-1, -beta, -alpha); + + // Libérez la mémoire! Libérez la mémoire! + for(j=0; j<(taillePlateau*taillePlateau); j++) + free(fils->plateau[j]); + free(fils->plateau); + + // Coupure alpha/beta: + if (fils->valeur > alpha) + { + noeud->meilleurX = fils->x; + noeud->meilleurY = fils->y; + alpha = fils->valeur; + index = i; + if (alpha >= beta) + { + //On élague ! + break; + } + } + } + + if (noeud->nbDeFils == 0) // Je ne peux pas jouer + { + noeud->nbDeFils = 1; // J'ai donc une seule branche: passer + + (noeud->listeFils)[0] = malloc(sizeof(NOEUD)); + NOEUD * fils = (noeud->listeFils)[0]; + fils->listeFils = NULL; + fils->nbDeFils = 0; + fils->plateau = copiePlateau(plateau); + + fils->couleur = !(noeud->couleur); + fils->x = -1; // Inutile pour le moment + fils->y = -1; + + // Je saute donc l'étape "jouer le coup" + // Et je calule la valeur des fils + fils->valeur = -minmax(fils->plateau, fils, profondeur-1, -beta, -alpha); + alpha = fils->valeur; + for(j=0; j<(taillePlateau*taillePlateau); j++) + free(fils->plateau[j]); + free(fils->plateau); + } + + + // Le Front de Libération de la Mémoire intervient + + free(listeValides); + + for(i=0; i<(noeud->nbDeFils); i++) + free((noeud->listeFils)[i]); + free(noeud->listeFils); + + return alpha; +} + diff --git a/lib/libIA-dumb.h b/lib/libIA-dumb.h new file mode 100644 index 0000000..5545bc5 --- /dev/null +++ b/lib/libIA-dumb.h @@ -0,0 +1,31 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef _LIB_IA_H +#define _LIB_IA_H + + +#include "libCases.h" + +int meilleurXY(CASE *plateau[], char couleur, int * x, int * y); +int minmax(CASE *plateau[], NOEUD * noeud, int profondeur, int alpha, int beta); + +#endif + diff --git a/lib/libIA.c b/lib/libIA.c new file mode 100644 index 0000000..69fe5e7 --- /dev/null +++ b/lib/libIA.c @@ -0,0 +1,366 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include +#include +#include "libDefine.h" +#include "libIA.h" +#include "libPlay.h" +#include "libDisplay.h" // Pour les messages de debug + +extern int taillePlateau; +extern arguments args; + +//! Place les meilleures coordonnées dans x et y +int meilleurXY(CASE *plateau[], char couleur, int * x, int * y) +{ + NOEUD noeud; // On crée le noeud-père + noeud.couleur = !couleur; // C'est l'adversaire qui vient de jouer + + // On récupère ici la valeur du plateau. + // On ne s'en sert actuellement pas mais bon... + int valeur = minmax(plateau, &noeud, 6, -INFINI, INFINI); + if (args.verbose) + erreur("Veleur supposée du coup: %d\n", valeur); + + // On récupère les coordonnées du meilleur coup directement fils + *x = noeud.meilleurX; + *y = noeud.meilleurY; + + if (args.verbose) + erreur("Valeur de la case: %d\n", valeurCase(*x, *y)); + + return 0; +} + +//! Calcule l'arbre des possibilités et renvoie la valeur du noeud en cours +/** + * Implémentation de l'algorithme Minimax + * S'appelle récursivement pour calculer la valeur d'un noeud à partir des + * noeuds fils. + * Si un noeud est terminal, sa valeur est sa valeur heuristique (pour le + * moment, c'est tout simplement le différentiel de score. Il n'y a pas de + * fonction heuristique). Sinon, elle est égale à la plus basse valeur des + * fils. (Grâce à la simplification Negamax, pas besoin d'alterner entre plus + * bas et plus haut selon qu'on est sur un noeud ennemi ou allié). + * A venir: heuristique; élagage + */ +int minmax(CASE *plateau[], NOEUD * noeud, int profondeur, int alpha, int beta) +{ + if (profondeur <= 0) // Si on est un noeud terminal on renvoie la valeur du plateau + { + int score = valeurPlateau(!noeud->couleur, plateau); + return score; + } + + int index; + int i, j; + int * listeValides = malloc(taillePlateau * taillePlateau * sizeof(int)); + + // On calcule le nombre de fils et on alloue la liste des fils en + // onséquence. + noeud->nbDeFils = nbCoupsValides(!(noeud->couleur), plateau, listeValides); + //if (noeud->nbDeFils > 2) + // noeud->nbDeFils = 2; + if (noeud->nbDeFils) + noeud->listeFils = calloc(noeud->nbDeFils, sizeof(NOEUD *)); // calloc met la mémoire à 0 + else + noeud->listeFils = malloc(1*sizeof(NOEUD)); // Si le joueur ne peut pas jouer, il passe: 1 noeud + + for(i=0; i<(noeud->nbDeFils); i++) + { + // On alloue le noeud fils + (noeud->listeFils)[i] = malloc(sizeof(NOEUD)); + NOEUD * fils = (noeud->listeFils)[i]; + fils->listeFils = NULL; + fils->nbDeFils = 0; + + // On crée une copie de travail du plateau + // (Très consommateur de mémoire) + fils->plateau = copiePlateau(plateau); + + // On calcule ses coordonnées + fils->x = listeValides[i]/taillePlateau; + fils->y = listeValides[i]%taillePlateau; + fils->couleur = !(noeud->couleur); + + // On simule le coup sur la copie + jouerCoup(fils->x, fils->y, fils->couleur, fils->plateau); + + // Convention Negamax + fils->valeur = -minmax(fils->plateau, fils, profondeur-1, -beta, -alpha); + + // Libérez la mémoire! Libérez la mémoire! + for(j=0; j<(taillePlateau*taillePlateau); j++) + free(fils->plateau[j]); + free(fils->plateau); + + // Coupure alpha/beta: + if (fils->valeur > alpha) + { + noeud->meilleurX = fils->x; + noeud->meilleurY = fils->y; + alpha = fils->valeur; + index = i; + if (alpha >= beta) + { + //On élague ! + break; + } + } + } + + if (noeud->nbDeFils == 0) // Je ne peux pas jouer + { + noeud->nbDeFils = 1; // J'ai donc une seule branche: passer + + (noeud->listeFils)[0] = malloc(sizeof(NOEUD)); + NOEUD * fils = (noeud->listeFils)[0]; + fils->listeFils = NULL; + fils->nbDeFils = 0; + fils->plateau = copiePlateau(plateau); + + fils->couleur = !(noeud->couleur); + fils->x = -1; // Inutile pour le moment + fils->y = -1; + + // Je saute donc l'étape "jouer le coup" + // Et je calule la valeur des fils + fils->valeur = -minmax(fils->plateau, fils, profondeur-1, -beta, -alpha); + alpha = fils->valeur; + for(j=0; j<(taillePlateau*taillePlateau); j++) + free(fils->plateau[j]); + free(fils->plateau); + } + + + // Le Front de Libération de la Mémoire intervient + + free(listeValides); + + for(i=0; i<(noeud->nbDeFils); i++) + free((noeud->listeFils)[i]); + free(noeud->listeFils); + + return alpha; +} + +int valeurPlateau(char couleur, CASE *plateau[]) +{ + int i; + + int scorePondere[2]={0, 0}, scoreMobilite[2]={0, 0}, + scoreLignes[2]={0, 0}, scoreBrut[2]={0, 0}; + + float totalLignes=0, totalMobilite=0, + totalBrut=0, totalPondere=0; + + int fPondere , fMobilite, + fLignes, fBrut; // les facteur qui viennent ponderer les scores + /* + * La mobilite prend plus d'importance au fur et a mesure qu'on avance dans + * le jeu, idem pour le score brut mais l'importance vient plus + * progressivement + * + * Le score pondéré prend de l'importance en milieu de jeu et en perd au + * fur et à mesure + * + * Le score des lignes prend de l'importance en milieu de jeu et en gagne + * petit a petit, mais jamais trop + * + * Le score brut prend de l'importance tardivement mais devient presque la + * seule vers la fin + */ + + + /* * * * *\ + BRUT + \* * * * */ + + score(plateau, scoreBrut); + if (scoreBrut[BLANC] + scoreBrut[NOIR] > 0) // Au moins un joueur a des lignes + { + // Le total est la proportion des points qu'a le joueur + totalBrut = proportion((float) scoreBrut[(int) couleur], (float) scoreBrut[(int) !couleur]); + fBrut = 1; + } + else // Personne n'a de ligne + { + fBrut = 0; + } + //erreur("Total Brut: %f\n", totalBrut); + + + /* * * * *\ + PONDERE + \* * * * */ + + for (i=0; icouleur; + if (contenu == BLANC || contenu == NOIR) + scorePondere[(int) contenu] += valeurCase(x, y); + //erreur("Valeur de la case %d,%d: %d\n", x, y, valeurCase(x, y)); + } + if (scoreBrut[BLANC] + scoreBrut[NOIR] > 0) // Au moins un joueur a des lignes + { + // Le total est la proportion des points qu'a le joueur + totalPondere = proportion((float) scorePondere[(int) couleur], (float) scorePondere[(int) !couleur]); + fPondere = 5; + } + else // Personne n'a de ligne + { + fPondere = 0; + } + //erreur("Total pondéré:%f\n", totalPondere); + + + /* * * * *\ + LIGNES + \* * * * */ + + for(i=0; i0) + scoreLignes[(int) couleur] += lin; + else + scoreLignes[(int) !couleur] -= lin; + + if (col>0) + scoreLignes[(int) couleur] += col; + else + scoreLignes[(int) !couleur] -= col; + } + if (scoreLignes[BLANC] + scoreLignes[NOIR] > 0) // Au moins un joueur a des lignes + { + // Le total est la proportion des points qu'a le joueur + totalLignes = proportion((float) scoreLignes[(int) couleur], (float) scoreLignes[(int) !couleur]); + fLignes = 1.5; + //erreur("Total Lignes:%f\n", totalLignes); + } + else // Personne n'a de ligne + { + fLignes = 0; + } + + /* * * * *\ + MOBILITE + \* * * * */ + int * temp = malloc(taillePlateau*taillePlateau*sizeof(int)); + scoreMobilite[BLANC] = nbCoupsValides(BLANC, plateau, temp); + scoreMobilite[NOIR] = nbCoupsValides(NOIR, plateau, temp); + free(temp); + if (scoreMobilite[BLANC] + scoreMobilite[NOIR] > 0) + { + totalMobilite = proportion((float) scoreMobilite[(int) couleur], (float) scoreMobilite[(int) !couleur]); + fMobilite = 2; + } + else + { + fMobilite = 0; + } + + int retour = 100 * ((totalPondere*fPondere) + + (totalBrut*fBrut) + + (totalLignes*fLignes) + + (totalMobilite*fMobilite)) / + (fPondere+fBrut+fLignes+fMobilite); + + //erreur("Valeur du plateau suivant:%d", retour); + //affichePlateau(plateau); + + return retour; +} + +int valeurColonne(int colonne, char couleur, CASE *plateau[]) +{ + int pions[4] = {0, 0, 0, 0}; // Seuls les deux premieres cases seront lues. + // En avoir 4 permet seulement d'avoir moins + // de tests + int i; + + for (i=0; icouleur])++; + + if (pions[(int) couleur] + pions[JOKER] >= taillePlateau-1) // La colonne est au joueur: Il a toute la colonne (sauf éventuellement un point) + return max(1, abs( (taillePlateau/2) - colonne)); // sans le max, renverrait 0 pour la colonne du milieu... + + // On renvoie un négatif si c'est l'ennemi + if (pions[!couleur] + pions[JOKER] >= taillePlateau-1) + return - max(1, abs( (taillePlateau/2) - colonne)); + + return 0; +} + +int valeurLigne(int ligne, char couleur, CASE *plateau[]) +{ + int pions[4] = {0, 0, 0, 0}; // Seuls les deux premieres cases seront lues. + // En avoir 4 permet seulement d'avoir moins + // de tests + int i; + + for (i=0; icouleur])++; + + if (pions[(int) couleur] + pions[JOKER] >= taillePlateau-1) // La ligne est au joueur: Il a toute la ligne (sauf éventuellement un point) + return max(1, abs( (taillePlateau/2) - ligne)); // sans le max, renverrait 0 pour la ligne du milieu... + + // On renvoie un négatif si c'est l'ennemi + if (pions[!couleur] + pions[JOKER] >= taillePlateau-1) + return - max(1, abs( (taillePlateau/2) - ligne)); + + return 0; +} + +int valeurCase(int x, int y) +{ + x = min(x, taillePlateau-x-1); + y = min(y, taillePlateau-y-1); + if (x > 1 && y > 1) // On est au milieu du plateau + return 40*(x+y)*taillePlateau; + + if (x == 1 || y == 1) // On est sur l'avant dernière ligne + { + if (x==y) // On est en diagonale du coin + return 0; // La plus basse valeur + if (x==0 || y==0) // On est sur un bord, à coté d'un coin + return 50*taillePlateau; + // Sinon: + return 150*taillePlateau; + } + + if (x == 0 || y == 0) // On est sur un bord, mais pas a coté du coin + { + if (x==y) // On est sur le coin !!! + return 3500*taillePlateau; + // Sinon, on est juste sur un bord: + return 600*taillePlateau; + } + + if (args.verbose) + erreur("PAS GLOP!!!!\n"); + return 0; + +} + diff --git a/lib/libIA.h b/lib/libIA.h new file mode 100644 index 0000000..65e9a91 --- /dev/null +++ b/lib/libIA.h @@ -0,0 +1,34 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef _LIB_IA_H +#define _LIB_IA_H + +#include "libCases.h" + +int meilleurXY(CASE *plateau[], char couleur, int * x, int * y); +int minmax(CASE *plateau[], NOEUD * noeud, int profondeur, int alpha, int beta); +int valeurPlateau(char couleur, CASE *plateau[]); +int valeurCase(int x, int y); +int valeurLigne(int ligne, char couleur, CASE *plateau[]); +int valeurColonne(int colonne, char couleur, CASE *plateau[]); + +#endif + diff --git a/lib/libPlay.c b/lib/libPlay.c new file mode 100644 index 0000000..d4c6f1d --- /dev/null +++ b/lib/libPlay.c @@ -0,0 +1,686 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libPlay.c + * Librairie indépendante du mode d'affichage. + * Elle gère toutes les règles du jeu et s'occupe d'effectuer les mouvements + * comme les retournements de pions. + */ + +#include +#include +#include "libPlay.h" +#include "libDefine.h" +#include "libDisplay.h" +#include "libIA.h" + +static int elaguer(NOEUD * noeud); + +static NOEUD tronc; // Le plateau d'origine +static NOEUD * actuel; // Pointe en permanence sur le plateau en cours + +extern int taillePlateau; + +//! Renvoie 0 si le coup n'est pas valide, le nombre de pièces qu'il retourne sinon. +/** + * Cette fonction renvoie le nombre de pièces à retourner et met les + * coordonnées des pièces à retourner dans le pointeur listeCoups. + * + * La liste increments contient les vecteurs selon lesquels parcourir le + * tableau: on suit toutes les droites et diagonales (première boucle for). + * Au début de chaque vecteur, on vérifie qu'on reste dans la plateau, que + * la case immédiatement n'est ni vide ni de la couleur du joueur. Dans le + * cas contraire, on passe immédiatement au vecteur suivant. + * Une fois ces prérequis vérifiés, on parcourt la suite du vecteur à la + * recherche d'une pierre amie (le while). On met les coordonnées des pions + * qui se trouvent sur le chemin. Si on trouve effectivement une pierre amie, + * le compteur total de pion à retourner est incrémenté. + * coupsTemp permet, si on ne rencontre pas d'amie, de ne pas fausser le compte + * de coups + * + * A tout moment, si on rencontre un joker, on le saute, c'est à dire qu'on + * fait un continue. +*/ +char lister(int x,int y,char couleur,CASE *plateau[], int listeCoups[]) +{ + CASE caseDepart; + char increments[8][2] = + { + {-1, -1}, + {-1, 0}, + {-1, 1}, + { 0, 1}, + { 1, 1}, + { 1, 0}, + { 1, -1}, + { 0, -1} + }; // Liste des vecteurs + int inc=0; // Parcourt les vecteurs + int coups=0, coupsTemp; // Compteur de nombre de pions retournés + char rencontre = 0; + + caseDepart = *adresseParXY(x, y, plateau); + + if (caseDepart.couleur != VIDE) + return 0; + + // On parcourt les vecteurs + for (inc=0; inc<8; inc++) + { + char incX=increments[inc][0], incY=increments[inc][1]; + char couleurCase; + CASE * caseTemp; + + caseTemp = caseSuivante(caseDepart, incX, incY, plateau); + // Si on est au bord du plateau ou s'il y a eu une erreur + if (caseTemp == NULL) + continue; + // Si on tombe ensuite sur une case de la meme couleur ou vide, on saute + if ( (caseTemp->couleur == couleur) || (caseTemp->couleur == VIDE) ) + continue; + + // Dans les autres cas, on continue d'incrementer + coupsTemp=1; // On retourne potentiellement 1 pion + // On l'ajoute à la liste des coups + listeCoups[coups] = (caseTemp->x)*taillePlateau + caseTemp->y; + while (1) // Pas besoin de vérification puisqu'on sort avec un break + { + caseTemp = caseSuivante(*caseTemp, incX, incY, plateau); + if (caseTemp == NULL) + break; // Il y a pas de case suivante. On est arrivé au bord sans trouver d'ami + couleurCase = caseTemp->couleur; + + // Si on tombe sur le joker, on passe cette case: + if (couleurCase == JOKER) + { + continue; + } + // Case Vide, Stop: + if (couleurCase == VIDE) + { + break; + } + // Si on tombe sur un ami: + if (couleurCase == couleur) + { + rencontre = 1; + break; // On a trouve qqn et on a rentre les coups. On passe au vecteur suivant + } + // On est tombé sur un ennemi, on l'ajoute + listeCoups[coups + (coupsTemp++)] = (caseTemp->x)*taillePlateau + caseTemp->y; + } + if (rencontre) + coups += coupsTemp; + coupsTemp = 0; + rencontre = 0; + } + + return coups; +} + +//! Renvoie 1 si le coup est valide, 0 pour invalide +char valide(int x, int y, char couleur, CASE *plateau[]) +{ + CASE caseDepart; + char increments[8][2] = + { + {-1, -1}, + {-1, 0}, + {-1, 1}, + { 0, 1}, + { 1, 1}, + { 1, 0}, + { 1, -1}, + { 0, -1} + }; // Liste des vecteurs + int inc=0; // Parcourt les vecteurs + char rencontre = 0; + + caseDepart = *adresseParXY(x, y, plateau); + + if (caseDepart.couleur != VIDE) + return 0; + + // On parcourt les vecteurs + for (inc=0; inc<8; inc++) + { + char incX=increments[inc][0], incY=increments[inc][1]; + char couleurCase; + CASE * caseTemp; + + caseTemp = caseSuivante(caseDepart, incX, incY, plateau); + // Si on est au bord du plateau ou s'il y a eu une erreur + if (caseTemp == NULL) + continue; + // Si on tombe ensuite sur une case de la meme couleur ou vide, on saute + if ( (caseTemp->couleur == couleur) || (caseTemp->couleur == VIDE) ) + continue; + + // Dans les autres cas, on continue d'incrementer + do + { + caseTemp = caseSuivante(*caseTemp, incX, incY, plateau); + if (caseTemp == NULL) + break; // Il y a pas de case suivante. On est arrivé au bord sans trouver d'ami + couleurCase = caseTemp->couleur; + + // Si on tombe sur le joker, on passe cette case: + if (couleurCase == JOKER) + continue; + // Case Vide, Stop: + else if (couleurCase == VIDE) + break; + // On a trouvé un pote ! + else if (couleurCase == couleur) + rencontre = 1; + } while(!rencontre); + if (rencontre) + return 1; // Au moins 1 vecteur + } + return 0; // Rien trouvé: pas valide +} + +//! Renvoie le nombre de coups valides +char nbCoupsValides(char couleur, CASE *plateau[], int listeValides[]) +{ + char i, j; + int coups=0; + + for(i=0; icouleur; + + // Le reste est tout con + if (couleur == BLANC) + couleur = NOIR; + // Important tout de même de else if, sinon ça ne marche pas. + else if (couleur == NOIR) + couleur = BLANC; + // Si c JOKER VIDE ou quoi que ce soit d'autre on se casse, c'est pas notre boulot. + else + return; + caseARetourner->couleur = couleur; +} + +//! Joue le tour actuel si possible. +/** + * Cette fonction, appelée par le main, joue le tour d'un joueur passé + * en argument. S'il y a lieu, il retourne les pions et place le pion du + * joueur. + * Elle renvoie ensuite le nombre de pièces retournées. + * Donc si le joueur ne peut pas jouer, la fonction ne fait rien et renvoie 0. + */ +int peutJouer(char couleur, CASE *plateau[]) +{ + int i, j; + + // On cherche s'il existe au moins 1 coup possible + for (i=0; icouleur = couleur; // On pose le pion + + free(listeCoups); + return nbCoups; +} + +//! Teste la fin de partie. +/** + * La partie se finit si le plateau est rempli ou si un joueur n'as plus de + * pièces sur le plateau (Là, il l'a mauvaise). Dans ce cas cette fonction renvoi 1. + * Tant que la partie n'est pas finie, cette fonction renvoi 0 + */ +int testFinPartie(CASE *plateau[]) +{ + int i, j; + int unicolore=1, plein=1; + char couleur[2] = {0, 0}; + + for (i=0; icouleur == BLANC) + { + points[0]++; + } + else if (adresseParXY(i, j, plateau)->couleur == NOIR) + { + points[1]++; + } + } + } +} + +//! Renvoit un simple pointeur comme tableau multidim +/** + * Crée et envoie une liste de pointeurs qui représente le tableau. + * Le pointeur renvoyé représente les colonne et chaque pointeur dans cette + * liste est une ligne. Le tableau renvoyé est initialisé à VIDE. +*/ +CASE ** createPlateau() +{ + // On crée une liste de pointeurs sur les cases + CASE ** plateau = malloc(taillePlateau * taillePlateau * sizeof(CASE *)); + //erreur("Création d'un plateau à l'adresse %p\n", plateau); + // On crée maintenant chaque case, et on met son pointeur dans la liste + int i=0; + for (i=0;i<(taillePlateau*taillePlateau);i++) + { + plateau[i] = malloc(sizeof(CASE)); + plateau[i]->x = i / taillePlateau; + plateau[i]->y = i % taillePlateau; + plateau[i]->couleur = VIDE; + } + + // Cette fonction renvoit un pointeur sur le plateau + // pour modif et affichage ultérieur. + return plateau; +} + +//! Copie un plateau passé en argument. utilise taillePlateau +CASE ** copiePlateau(CASE *plateau[]) +{ + CASE ** copie = malloc(taillePlateau * taillePlateau * sizeof(CASE *)); + //erreur("Copie du plateau %p en %p\n", plateau, copie); + int i; + for(i=0; i<(taillePlateau*taillePlateau); i++) + { + copie[i] = malloc(sizeof(CASE)); + copie[i]->x = i / taillePlateau; + copie[i]->y = i % taillePlateau; + copie[i]->couleur = adresseParXY(copie[i]->x, copie[i]->y, plateau)->couleur; + } + return copie; +} + +//! Rempli le centre d'un tableau passé en argument +/** + * Initialise la partie en ajoutant au tableau vide le carré central donné + * en consigne. Il contient un Joker en son centre. +*/ +void initPlateau(CASE *plateau[]) +{ + // Le motif donné par la consigne : + char motif[9]; + if (taillePlateau % 2 == 1) // Plateau Impair + { + // La position de début du motif est à : + int debut = (taillePlateau/2)-1; + + motif[0] = BLANC; motif[1] = NOIR; motif[2] = BLANC; + motif[3] = BLANC; motif[4] = JOKER; motif[5] = NOIR; + motif[6] = NOIR; motif[7] = BLANC; motif[8] = NOIR; + + int i=0,j=0; + for (i=0;i<3;i++) + { + for (j=0;j<3;j++) + { + adresseParXY(debut+i, debut+j, plateau)->couleur = motif[j*3+i]; + } + } + } + else + { + // La position de début du motif est à : + int debut = (taillePlateau/2)-1; + + motif[0] = BLANC; motif[1] = NOIR; + motif[2] = NOIR; motif[3] = BLANC; + + int i=0,j=0; + for (i=0;i<2;i++) + { + for (j=0;j<2;j++) + { + adresseParXY(debut+i, debut+j, plateau)->couleur = motif[j*2+i]; + } + } + } + +} + +//! Trouve un coup et l'envoit +/** + * Fait appel à la libIA pour trouver le meilleur coup dans la position donnée + * Envoit ensuite le coup via la libDisplay (ecrire()) + */ +int jouerSonTour(char couleur, CASE *plateau[]) +{ + int x, y; + int retour; + + //erreur("On afiche le plateau que reçoit l'IA:\n"); + affichePlateau(plateau); + + if (!peutJouer(couleur, plateau)) + { + retour = meilleurXY(plateau, couleur, &x, &y); + pasDeCoup(); + //erreur("L'IA ne peut pas jouer\n"); + return 1; + } + else + { + retour = meilleurXY(plateau, couleur, &x, &y); // Trouve le meilleur coup + if (retour) + return -1; // Erreur ! + + envoyerXY(x, y); + retour = jouerCoup(x, y, couleur, plateau); + if (retour == 0) + return -1; // Erreur comise + } + + return 0; // Tout s'est bien déroulé +} + +//! Lit le coup adverse et le joue +/** + * Via la libDisplay, on lit le coup adverse (lireCoup()) + * Puis on le joue. S'il est illégal, on retourne un erreur. + */ +int jouerTourAdverse(char couleur, CASE *plateau[]) +{ + int retour; + char x; + int y; + + retour = lireCoup(&x, &y); + if (retour == 0) // L'adversaire a joué + { + retour = jouerCoup(x, y, !couleur, plateau); + if (retour == 0) // Aucun pion retourné + return -1; // L'adversaire a joué un coup illégal + } + else if (retour == 1) + return 1; // L'adversaire n'avait pas de coup} + + return 0; // L'adversaire a joué correctement +} + +//! Joue le tour actuel si possible. +/** + * Cette fonction, appelée par le main, joue le tour d'un joueur passé + * en argument. S'il y a lieu, il retourne les pions et place le pion du + * joueur. + * Elle renvoie ensuite le nombre de pièces retournées. + * Donc si le joueur ne peut pas jouer, la fonction ne fait rien et renvoie 0. + */ +int jouerTourSimple(char couleur, CASE *plateau[]) +{ + int nbCoups=0; + int coords[2] = {0, 0}; + + // On cherche s'il existe au moins 1 coup possible + if(!peutJouer(couleur, plateau)) + return 0; // Le joueur ne peut pas jouer + + // On demande le coup du joueur + do + { + demanderXY(coords); + nbCoups = jouerCoup(coords[0], coords[1], couleur, plateau); + } + while (nbCoups == 0); + + return nbCoups; +} + +//! Initialise l'historique avec le plateau/tronc +/** + * Après cette fonction, le tronc contient le plateau de départ + * (On peut partir avec un plateau de partie déjà en cours) + * Et actuel pointe sur le tronc + */ +NOEUD * initHistorique(CASE *plateau[], char couleur) +{ + tronc.nbDeFils = 0; + tronc.listeFils = NULL; + tronc.plateau = copiePlateau(plateau); + tronc.couleur = !couleur; + tronc.pere = NULL; + + actuel = &tronc; + + return &tronc; +} + +//! ajoute un fils au noeud actuel +/** + * L'historique supporte les variantes: un noeud peut avoir plusieurs fils + * Cette fonction retourne un pointeur vers le noeud crée + */ +NOEUD * majHistorique(CASE *plateau[], char couleur) +{ + NOEUD * fils = malloc(sizeof(NOEUD)); + fils->nbDeFils = 0; + fils->listeFils = NULL; + fils->plateau = copiePlateau(plateau); + fils->couleur = couleur; + fils->pere = actuel; + + // TODO : Si le fils existe déjà, il faut pas le recrée + + ajouteFils(actuel, fils); + + actuel = fils; + return actuel; // On informe le programme de l'emplacement du nouveau noeud +} + +//! Libère les noeuds de l'historique +void endHistorique() +{ + int j; + elaguer(&tronc); // On passe du désherbant hyperpuissant + + for (j=0; j<(taillePlateau*taillePlateau); j++) + free(tronc.plateau[j]); + free(tronc.plateau); +} + +//! renvoie la couleur du joueur dont c'est le tour +/** + * Fais pointer actuel sur son propre père. + * Recopie ensuite le plateau du noeud actuel dans le plateau passé en + * argument. + * Renvoie BLANC si on est au tronc; l'inverse de la couleur du plateau sinon. + */ +char reculerHistorique(CASE * plateau[]) +{ + if (actuel->pere != NULL) + { + actuel = actuel->pere; + + int j; + for (j=0; jplateau[j]); + } + + return !(actuel->couleur); +} + +//! renvoie la couleur du joueur dont c'est le tour +/** + * Fais pointer actuel sur le noeud passé en argument + * Recopie ensuite le plateau du noeud actuel dans le plateau passé en + * argument. + * Renvoie BLANC si on est au tronc; l'inverse de la couleur du plateau sinon. + */ +char sauterHistorique(CASE * plateau[], NOEUD * destination) +{ + + if (destination == NULL) + return -1; + + int j; + actuel = destination; + for (j=0; jplateau[j]); + + return !(actuel->couleur); +} + +//! renvoie la couleur du joueur dont c'est le tour +/** + * Fais pointer actuel sur son premier fils + * Recopie ensuite le plateau du noeud actuel dans le plateau passé en + * argument. + * Renvoie BLANC si on est au tronc; l'inverse de la couleur du plateau sinon. + */ +char avancerHistorique(CASE * plateau[]) +{ + if (actuel->nbDeFils <= 0 || actuel->listeFils == NULL) + return (actuel->couleur == VIDE) ? BLANC : !(actuel->couleur); + + actuel = actuel->listeFils[actuel->nbDeFils - 1]; + + int j; + for (j=0; jplateau[j]); + + return !(actuel->couleur); +} + +//! Ajoute un fils à la liste d'un noeud +/** + * Utilise realloc pour agrandir la liste du pere(premier argument) et + * ajoute un pointeur vers le fils(2ème argument) à la liste. + */ +void ajouteFils(NOEUD * pere, NOEUD * fils) +{ + (pere->nbDeFils)++; + // On étend la liste + pere->listeFils = realloc(pere->listeFils, pere->nbDeFils * sizeof(NOEUD *)); + + pere->listeFils[pere->nbDeFils - 1] = fils; +} + +//! libère tout les fils d'un noeud +static int elaguer(NOEUD * noeud) +{ + int i, j; + for (i=0; inbDeFils; i++) + { + NOEUD * fils = noeud->listeFils[i]; + if (fils->listeFils != NULL) // Ce fils a des fils, donc appel récursif de cette fonction + elaguer(fils); + + // On libère le plateau: + for(j=0; j<(taillePlateau*taillePlateau); j++) + free((fils->plateau)[j]); + free(fils->plateau); + + // On peut maintenant libérer ce fils + free(noeud->listeFils[i]); + } + // On libère la liste des fils: + free(noeud->listeFils); + + return 0; +} + diff --git a/lib/libPlay.h b/lib/libPlay.h new file mode 100644 index 0000000..9067a32 --- /dev/null +++ b/lib/libPlay.h @@ -0,0 +1,54 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libPlay.h + * Prototypes de libPlay.c + */ + +#ifndef _LIB_PLAY_H +#define _LIB_PLAY_H + +#include "libCases.h" + +char lister(int x, int y, char couleur, struct _CASE *plateau[], int listeCoups[]); +char valide(int x, int y, char couleur, struct _CASE *plateau[]); +char nbCoupsValides(char couleur, CASE *plateau[], int listeValides[]); +void retourne(int x, int y, struct _CASE *plateau[]); +int peutJouer(char couleur, CASE *plateau[]); +int jouerCoup(int x, int y, char couleur, struct _CASE *plateau[]); +int testFinPartie(struct _CASE *plateau[]); +void score(struct _CASE *plateau[], int * points); +struct _CASE ** createPlateau(); +struct _CASE ** copiePlateau(struct _CASE *plateau[]); +void initPlateau(struct _CASE *plateau[]); +int jouerSonTour(char couleur, CASE *plateau[]); +int jouerTourAdverse(char couleur, CASE *plateau[]); +int jouerTourSimple(char couleur, CASE *plateau[]); +NOEUD * initHistorique(CASE *plateau[], char couleur); +NOEUD * majHistorique(CASE *plateau[], char couleur); +void endHistorique(); +char reculerHistorique(CASE * plateau[]); +char sauterHistorique(CASE * plateau[], NOEUD * destination); +char avancerHistorique(CASE * plateau[]); +void ajouteFils(NOEUD * pere, NOEUD * fils); + +#endif + diff --git a/olono_X11/AUTHORS b/olono_X11/AUTHORS new file mode 100644 index 0000000..dba7a44 --- /dev/null +++ b/olono_X11/AUTHORS @@ -0,0 +1,2 @@ +David Wagner +Martin Potier diff --git a/olono_X11/AUTO.sh b/olono_X11/AUTO.sh new file mode 100755 index 0000000..ce1fdaa --- /dev/null +++ b/olono_X11/AUTO.sh @@ -0,0 +1,5 @@ +aclocal +autoheader +touch stamp-h +autoconf +automake -a -c diff --git a/olono_X11/COPYING b/olono_X11/COPYING new file mode 100644 index 0000000..94a9ed0 --- /dev/null +++ b/olono_X11/COPYING @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. 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 +them 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 prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. 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. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey 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; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If 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 convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU 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 that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + 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. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +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. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + 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 +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + 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 3 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, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program 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, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU 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 Lesser General +Public License instead of this License. But first, please read +. diff --git a/olono_X11/ChangeLog b/olono_X11/ChangeLog new file mode 100644 index 0000000..f95b4df --- /dev/null +++ b/olono_X11/ChangeLog @@ -0,0 +1,16 @@ +Version 0.1 + Written in Python + Quite working referee + +Version 0.2 + Rewritten in C + Working referee + +Version 0.3 + Can finish a match and name the winner + Implementation des arguments + +Version 0.4 + New algorythm for validation function + Can play on a pseudo-sphere (meaning the borders are connected) + diff --git a/olono_X11/INSTALL b/olono_X11/INSTALL new file mode 120000 index 0000000..5bb6e7b --- /dev/null +++ b/olono_X11/INSTALL @@ -0,0 +1 @@ +/usr/share/automake-1.10/INSTALL \ No newline at end of file diff --git a/olono_X11/Makefile.am b/olono_X11/Makefile.am new file mode 100644 index 0000000..1daa4c3 --- /dev/null +++ b/olono_X11/Makefile.am @@ -0,0 +1,6 @@ +SUBDIRS = src \ + imgs \ + glade + + + diff --git a/olono_X11/NEWS b/olono_X11/NEWS new file mode 100644 index 0000000..8a99ec7 --- /dev/null +++ b/olono_X11/NEWS @@ -0,0 +1,3 @@ +I can't believe the news today. +Ow I cannot close my eyes and make it go away. +Sunday ... etc. diff --git a/olono_X11/README b/olono_X11/README new file mode 100644 index 0000000..21f99bc --- /dev/null +++ b/olono_X11/README @@ -0,0 +1,41 @@ +OloNO README . OloNO is Not an Othello +-------------------------------------- +this looks like an FAQ but it isn't ... + ++ Where does OloNO come from ? +------------------------------ +It started as a student project in ISEP 2008-2009© + + ++ What is OloNo ? +----------------- +Despite the retro acronym and all the Magritte's painting +OloNO is an Othello game. + + ++ I just recieved the package, how do I run it ? +------------------------------------------------ +I guess you are willing to compile and install OloNO. +You will find basic instructions about the process in the +INSTALL file. +But before you do so, you might want to consider this : +let's say you just received this package, you may proceed +to the install. + +To cut a long story short : + $ ./configure --prefix=YOURDIR + $ make + $ make install + +NOTE : if YOURDIR doesn't belong to your user, then you will +need to run make install as root. (using su, sudo, ...) + + ++ What is AUTO.sh +----------------- +AUTO.sh is a little homemade script that runs the autotools. +You don't need that if you just want to build and execute the program. +See section "How do I run it ?" + + +Have a nice day. diff --git a/olono_X11/TODO b/olono_X11/TODO new file mode 100644 index 0000000..0e140e8 --- /dev/null +++ b/olono_X11/TODO @@ -0,0 +1,5 @@ +A lot is TODO . +--------------- + +The main spot for the moment is to be able to play with it. + diff --git a/olono_X11/configure.ac b/olono_X11/configure.ac new file mode 100644 index 0000000..b10fa8e --- /dev/null +++ b/olono_X11/configure.ac @@ -0,0 +1,44 @@ +dnl Process this file with autoconf to produce a configure script. + +AC_INIT([OloNO], [0.4], [ail@isep.fr]) + +dnl Non GNU, but very handy : +AC_DEFINE_DIR([LIBDIR], [libdir], [Where the libs are placed to.]) +AC_DEFINE_DIR([DATADIR], [datadir], [Where data are placed to.]) +AC_DEFINE_DIR([INCLUDEDIR], [includedir], [Where headers are placed to.]) +AC_DEFINE_DIR([BINDIR], [bindir], [Where bin are places to.]) + +AC_CONFIG_HEADERS([config.h]) +###AC_CONFIG_LIBOBJ_DIR([src]) + +###AC_LIBOBJ([libIA]) +###AC_LIBOBJ([libPlay]) +###AC_LIBOBJ([libDisplay]) +###AC_LIBOBJ([libCases]) + +PACKAGE=olono +VERSION=0.4 + +AM_INIT_AUTOMAKE($PACKAGE,$VERSION) + +AC_PROG_LIBTOOL +AC_PROG_CC +AC_PROG_INSTALL +AC_PROG_RANLIB dnl This is required if any libraries are built in the package. + +AC_STDC_HEADERS + +PKG_CHECK_MODULES(DEPS, libglade-2.0 libgnomeui-2.0 >= 1.110.0) +AC_SUBST(DEPS_CFLAGS) +AC_SUBST(DEPS_LIBS) + +AM_CONDITIONAL(DEBUG, test "$enable_debug" = yes) + +### Attention : libs before the rest +AC_CONFIG_FILES([ +Makefile +src/Makefile +imgs/Makefile +glade/Makefile +]) +AC_OUTPUT diff --git a/olono_X11/glade/Makefile.am b/olono_X11/glade/Makefile.am new file mode 100644 index 0000000..2200f37 --- /dev/null +++ b/olono_X11/glade/Makefile.am @@ -0,0 +1,3 @@ +gladedir = $(datadir)/olono-gtk/glade +glade_DATA = olonoGUI.glade +EXTRA_DIST = $(glade_DATA) diff --git a/olono_X11/glade/olonoGUI.glade b/olono_X11/glade/olonoGUI.glade new file mode 100644 index 0000000..ad8c16f --- /dev/null +++ b/olono_X11/glade/olonoGUI.glade @@ -0,0 +1,1031 @@ + + + + + + True + GTK_WIN_POS_CENTER + + + + True + 4 + + + True + + + True + _Jeu + True + + + True + + + True + gtk-new + True + True + + + + + + True + + + + + True + gtk-preferences + True + True + + + + + + True + + + + + True + gtk-quit + True + True + + + + + + + + + + + True + Aid_e + True + + + True + + + True + gtk-about + True + True + + + + + + + + + + False + + + + + True + + + True + _Nouvelle partie + True + gtk-new + + + + False + + + + + True + gtk-preferences + + + + False + + + + + True + gtk-go-back + + + + False + + + + + True + gtk-go-forward + + + + False + + + + + False + 1 + + + + + True + 0 + 1 + + + + + + False + 2 + + + + + True + 2 + + + False + 3 + + + + + + + 5 + À propos de OloNO + False + GTK_WIN_POS_CENTER_ON_PARENT + True + GDK_WINDOW_TYPE_HINT_DIALOG + True + False + OloNO + 0.4 + Merci à moi, et à toi aussi. +Et l'autre qui passe là-bas aussi. + +(faites gaffe c'est truffé de pièges ... Y'en a au moins 42) + Done with fun for an ISEP project. +2008-2009 +GNU Othello arrives ! + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. 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 +them 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 prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. 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. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey 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; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If 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 convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU 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 that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + 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. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +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. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + 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 +state 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) <year> <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 3 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, see <http://www.gnu.org/licenses/>. + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + <program> Copyright (C) <year> <name of author> + This program 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, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +<http://www.gnu.org/licenses/>. + + The GNU 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 Lesser General +Public License instead of this License. But first, please read +<http://www.gnu.org/philosophy/why-not-lgpl.html>. + David WAGNER +Martin POTIER + + + + + 2 + + + True + GTK_BUTTONBOX_END + + + False + GTK_PACK_END + + + + + + + 5 + GTK_WINDOW_POPUP + Préférences + False + True + GTK_WIN_POS_CENTER_ALWAYS + True + GDK_WINDOW_TYPE_HINT_DIALOG + + + + + + True + 2 + + + True + 0 + GTK_SHADOW_NONE + 1 + + + True + + + True + True + Jouer contre l'ordinateur + 0 + True + + + + + + True + True + Afficher les coups possibles + 0 + True + + + + 1 + + + + + True + True + Les Blancs commencent + 0 + True + + + + 2 + + + + + True + True + L'ordinateur joue les Noirs + 0 + True + + + + 3 + + + + + True + + + True + Taille par défaut du plateu de jeu + + + + + True + True + 2 + True + True + 10 4 25 1 10 10 + True + True + + + + 1 + + + + + 4 + + + + + + + 1 + + + + + True + GTK_BUTTONBOX_END + + + True + True + True + gtk-close + True + 0 + + + + + + True + True + True + gtk-ok + True + 0 + + + + 1 + + + + + False + GTK_PACK_END + + + + + + diff --git a/olono_X11/imgs/Makefile.am b/olono_X11/imgs/Makefile.am new file mode 100644 index 0000000..82dcb00 --- /dev/null +++ b/olono_X11/imgs/Makefile.am @@ -0,0 +1,3 @@ +imgsdir = $(datadir)/olono-gtk/images +imgs_DATA = olono_caseB.png olono_caseTB.png olono_caseV.png olono_caseN.png olono_caseTN.png olono_caseJ.png +EXTRA_DIST = $(imgs_DATA) diff --git a/olono_X11/imgs/olono_caseB.png b/olono_X11/imgs/olono_caseB.png new file mode 100644 index 0000000..beb6742 Binary files /dev/null and b/olono_X11/imgs/olono_caseB.png differ diff --git a/olono_X11/imgs/olono_caseJ.png b/olono_X11/imgs/olono_caseJ.png new file mode 100644 index 0000000..eac3a88 Binary files /dev/null and b/olono_X11/imgs/olono_caseJ.png differ diff --git a/olono_X11/imgs/olono_caseN.png b/olono_X11/imgs/olono_caseN.png new file mode 100644 index 0000000..22394fe Binary files /dev/null and b/olono_X11/imgs/olono_caseN.png differ diff --git a/olono_X11/imgs/olono_caseTB.png b/olono_X11/imgs/olono_caseTB.png new file mode 100644 index 0000000..bee74b0 Binary files /dev/null and b/olono_X11/imgs/olono_caseTB.png differ diff --git a/olono_X11/imgs/olono_caseTN.png b/olono_X11/imgs/olono_caseTN.png new file mode 100644 index 0000000..9b1ce5c Binary files /dev/null and b/olono_X11/imgs/olono_caseTN.png differ diff --git a/olono_X11/imgs/olono_caseV.png b/olono_X11/imgs/olono_caseV.png new file mode 100644 index 0000000..6936a70 Binary files /dev/null and b/olono_X11/imgs/olono_caseV.png differ diff --git a/olono_X11/src/Makefile.am b/olono_X11/src/Makefile.am new file mode 100644 index 0000000..132eabb --- /dev/null +++ b/olono_X11/src/Makefile.am @@ -0,0 +1,33 @@ +lib_LTLIBRARIES = libCases.la libIA.la libPlay.la libDisplay.la libGUI.la + +libCases_la_SOURCES = libCases.c libDefine.h +libIA_la_SOURCES = libIA.c libDefine.h +libPlay_la_SOURCES = libPlay.c libDefine.h +libDisplay_la_SOURCES = libDisplay.c libDefine.h +libGUI_la_SOURCES = libGUI.c libDefine.h + +dist_include_HEADERS = libCases.h libIA.h libPlay.h libDisplay.h libGUI.h libDefine.h + + + + + +bin_PROGRAMS = olono-gtk + +### On indique les sources du programme +olono_gtk_SOURCES = main.c + +### On link les dépendances du programme. +olono_gtk_LDADD = $(DEPS_LIBS) libCases.la libIA.la libPlay.la libDisplay.la libGUI.la + +### C'est la section flag C, mais ils vont passer sous libtool. +### Donc suivant la version du compilo et des versions, -export-dynamic +### sera transformé en -Wl,--exort-dynamic (GCC) ou autre chose. +olono_gtk_LDFLAGS = -export-dynamic + +### Puis les flags C et libtool +if DEBUG +AM_CPPFLAGS = -ggdb -p -Wall -DDEBUG $(DEPS_CFLAGS) -DIMGS_DIR=\""$(datadir)/imgs"\" -DGLADE_DIR=\""$(datadir)/glade"\" +else +AM_CPPFLAGS = $(DEPS_CFLAGS) -DIMGS_DIR=\""$(datadir)/imgs"\" -DGLADE_DIR=\""$(datadir)/glade"\" +endif diff --git a/olono_X11/src/libCases.c b/olono_X11/src/libCases.c new file mode 100644 index 0000000..c7ba9c6 --- /dev/null +++ b/olono_X11/src/libCases.c @@ -0,0 +1,87 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include +#include "libDefine.h" +#include "libCases.h" + +extern arguments args; +extern int taillePlateau; + +//! retourne l'adresse de la case (x, y) +/** + * En plus de retourner un pointeur sur la case (x,y), elle peut permettre de + * vérifier la validité des coordonnées (retourne NULL si la case est hors du + * plateau.) + */ +CASE * adresseParXY(int x, int y, CASE *plateau[]) +{ + if (x>=taillePlateau || y>=taillePlateau + || x<0 || y<0) + return NULL; + + return plateau[x*taillePlateau + y]; +} + +//! Renvoie un pointeur sur la case suivante selon un vecteur +/** + * Prend une case et un vecteur en argument, ainsi que la taille du plateau et + * la liste des cases. Renvoie l'adresse de la case suivante sur ce vecteur + */ +CASE * caseSuivante(CASE depart, int incX, int incY, CASE *plateau[]) +{ + int x, y; + + // Si on arrive au bout du plateau (depart.x+incX = taillePlateau), on + // repart à 0. idem pour y + x = depart.x + incX; + if (x == taillePlateau) + { + if (args.Tore) + x = 0; + else + return NULL; + } + else if (x == -1) + { + if (args.Tore) + x = taillePlateau-1; + else + return NULL; + } + + y = depart.y + incY; + if (y == taillePlateau) + { + if (args.Tore) + y = 0; + else + return NULL; + } + else if (y == -1) + { + if (args.Tore) + y = taillePlateau-1; + else + return NULL; + } + + return adresseParXY(x, y, plateau); +} diff --git a/olono_X11/src/libCases.h b/olono_X11/src/libCases.h new file mode 100644 index 0000000..627aa53 --- /dev/null +++ b/olono_X11/src/libCases.h @@ -0,0 +1,51 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// Comme certaines librairies incluent cette lib et des libs qui l'incluent +// aussi, il ne faut le lire qu'une fois +#ifndef _LIB_CASES_H +#define _LIB_CASES_H + +#include "libDefine.h" + +//! Structure de case. +typedef struct _CASE +{ + char couleur; /**< Couleur de la case */ + int x, y; +} CASE; + +typedef struct _NOEUD +{ + int nbDeFils; + struct _NOEUD ** listeFils; // liste des pointeurs sur les fils (de taille nbDeFils) + struct _CASE ** plateau; + char x, y; + char valeur; + char couleur; + char meilleurX; + char meilleurY; + struct _NOEUD * pere; +} NOEUD; + +CASE * adresseParXY(int x, int y, CASE *plateau[]); +CASE * caseSuivante(CASE depart, int incX, int incY, CASE *plateau[]); +#endif + diff --git a/olono_X11/src/libDefine.h b/olono_X11/src/libDefine.h new file mode 100644 index 0000000..e986f0d --- /dev/null +++ b/olono_X11/src/libDefine.h @@ -0,0 +1,64 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libDefine.h + * Contient des macros et des structures pour tout le programme. + * Elles définissent les valeurs d'int associées aux 4 types de cases. De la + * même manière est définit la taille d'un plateau par défaut. + */ + +#ifndef _LIB_DEFINE_H +#define _LIB_DEFINE_H + +#define VIDE 3 +#define BLANC 0 +#define NOIR 1 +#define JOKER 2 + +#define INFINI 0x7FFFFFFF // 2^31 + +#define abs(X) ((X) > 0 ? (X) : -(X)) +#define max(X, Y) ((X) > (Y) ? (X) : (Y)) +#define min(X, Y) ((X) < (Y) ? (X) : (Y)) + +#define proportion(X, Y) ((X)) / ((X)+(Y)) + +/* This structure is used by main to communicate with parse_opt. */ +typedef struct _arguments +{ + int taillePlateau; /* Arguments for -t */ + char verbose; /* 1 si on doit aficher la grille, 0 sinon */ + char type[7]; /* humain ou ia */ + char couleur; /* 'N' ou 'B' */ + int Tore; /* Arguments for -T */ +} arguments; + +typedef struct _preferences +{ + int couleurDepart; + int allowIA; + int couleurIA; + int affJouable; + int taillePlateau; +} preferences; + +#endif + diff --git a/olono_X11/src/libDisplay.c b/olono_X11/src/libDisplay.c new file mode 100644 index 0000000..c92f6e2 --- /dev/null +++ b/olono_X11/src/libDisplay.c @@ -0,0 +1,279 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libDisplay.c (console) + * Contient les fonctions d'affichage en mode console: + * concerne aussi bien l'affichage de la grille que les entrées utilisateur. + */ + +#include +#include +#include +#include +#include +#include +#include "libDefine.h" +#include "libPlay.h" +#include "libDisplay.h" + +//! Demande les coordonnées au joueur +/** + * Cette fonction demande à l'utilisateur les coordonnées du point à jouer + * et les converti pour qu'elles correspondent aux indices en mémoire. +*/ +char demanderAction(char couleur) +{ + char retourScanf = '\0'; + + do + { + ecrire("%s, que voulez-vous faire: (J)ouer ou (R)eculer dans l'historique ? ", + (couleur == BLANC) ? "Blanc" : "Noir"); + scanf(" %c%*[^\n]", &retourScanf); // On scan un char puis n'importe quoi sauf un retour à la ligne + + int c; + // ... On vide le flux + while ( ((c = getchar()) != '\n') && c != EOF); + } + while (retourScanf != 'J' && retourScanf != 'R'); + + return retourScanf; +} + +//! Demande les coordonnées au joueur +/** + * Cette fonction demande à l'utilisateur les coordonnées du point à jouer + * et les converti pour qu'elles correspondent aux indices en mémoire. +*/ +void demanderXY(int coords[]) +{ + char x=0; + int y=0; + + do + { + printf("Entrez les coordonnées où jouer: "); + scanf(" %c%d%*[^\n]", &x, &y); // On scan un char puis un int puis n'importe quoi sauf un retour à la ligne + x = toupper(x); + + int c; + // ... On vide le flux + while ( ((c = getchar()) != '\n') && c != EOF); + } + while (!( x>='A' && (x-'A')=0 && ycouleur]); + } + erreur("\n"); // après chaque ligne, retour à la ligne + } + erreur(" "); + for (i=0;i 25)) + { + printf("Entrez une taille entre 4 et 25 : "); + retourScanf = scanf("%d%*[^\n]",&taillePlateau); + // Si le scanf a retourné une erreur ... + if (!retourScanf) + { + // ... On vide le flux + char c; + while ( ((c = getchar()) != '\n') && c != EOF); + } + else + // Si tout s'est bien passé, on enlève le \n final + getchar(); + } + + return taillePlateau; +} + +//! Dire bonjour : +void direBonjour() +{ +ecrire("\tOloNO Copyright (C) 2008 David Wagner && Martin Potier\n\ +\tThis program comes with ABSOLUTELY NO WARRANTY;\n\ +\tThis is free software, and you are welcome to redistribute it under\n\ +\tcertain conditions\n\n"); +ecrire("Bienvenue à OloNO\nOloNO is not an othello\n\n"); +} + +//! utilise ecrire() pour envoyer les coordonnées +void envoyerXY(int x, int y) +{ + ecrire("%c%d\n", x + 'A', taillePlateau - y - 1); +} + +//! utilise ecrire() pour signifier qu'il n'y a pas de coup possible +void pasDeCoup() +{ + write(STDOUT_FILENO, "pas de coup\n", 12); +} + +//! lit un coup sur stdin +/** + * Si "pas de coup" est reçu, on renvoit 1. + * Sinon, on renvoie 0 et on place les coordonnées dans x et y + * Cette fonction ne se charge pas de vérifier que les coordonnées soient + * bonnes: ele est utilisée par l'IA, qui doit s'arrêter en cas d'erreur de + * l'adversaire + */ +int lireCoup(char * x, int * y) +{ + char * input = malloc(20 * sizeof(char)); + char * copie = malloc(20 * sizeof(char)); + + read(STDIN_FILENO, input, 20); + + int i=0; + while((copie[i] = input[i]) && copie[i++] != '\n'); + copie[i] = '\0'; + free(input); + + if (strcmp(copie, "pas de coup\n") == 0) + { + free(copie); + return 1; // L'adversaire ne peut pas jouer + } + + sscanf(copie, "%c%d", x, y); + *x = (int) toupper(*x) - 'A'; + *y = taillePlateau - *y - 1; + + free(copie); + return 0; +} + +//! Affiche le score +/** + * Utilise l'erreur standard pour ne pas encombrer la stdin qui ne doit + * concerner que les coups joués + */ +void afficherScore(int points[]) +{ + if (points[0] > points[1]) + erreur("Les blancs gagnent par %d à %d\n", points[0], points[1]); + else if (points[1] > points[0]) + erreur("Les noirs gagnent par %d à %d\n", points[1], points[0]); + else + erreur("Partie nulle: %d partout\n", points[0]); +} + diff --git a/olono_X11/src/libDisplay.h b/olono_X11/src/libDisplay.h new file mode 100644 index 0000000..18ec4d5 --- /dev/null +++ b/olono_X11/src/libDisplay.h @@ -0,0 +1,47 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libDisplay.h + * Prototypes de libDisplay.c + */ + +#ifndef _LIB_DISPLAY_H +#define _LIB_DISPLAY_H + +#include "libCases.h" + +extern int taillePlateau; + +char demanderAction(char couleur); +void demanderXY(int coords[]); +void affichePlateau(CASE *plateau[]); +void direBonjour(); +void demanderXY(int coords[]); +void ecrire(char *chaine, ...); +void erreur(char *chaine, ...); +int demanderTaillePlateau(); +void envoyerXY(int x, int y); +void pasDeCoup(); +int lireCoup(char * x, int * y); +void afficherScore(int points[]); + +#endif + diff --git a/olono_X11/src/libGUI.c b/olono_X11/src/libGUI.c new file mode 100644 index 0000000..f3681ec --- /dev/null +++ b/olono_X11/src/libGUI.c @@ -0,0 +1,656 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libGUI.c + * Contient les fonctions de callback de l'interface graphique ainsi que des + * fonctions annexes appelées par les fonctions de callback. + */ + + +#include +#include +#include + +#include "libDefine.h" +#include "libDisplay.h" +#include "libGUI.h" +#include "libCases.h" +#include "libPlay.h" +#include "libIA.h" + + +extern int couleurDepart; +extern int allowIA; +extern int couleurIA; +extern int affJouable; +extern int taillePlateau; + +extern int jeton; +extern int aPuJouer[]; +extern window * wOlono; +extern CASE **plateau; +extern arguments args; +extern preferences prefs; +extern NOEUD *tronc; +extern int points []; +extern FILE *fichierPreferences; + +/// ICI Section fonction annexe + +//! Cette fonction se charge de recopier le tableau en mémoire. +/** + * Cette fonction rafraichit le tableau (GtkTable) par rapport à son + * homologue en mémoire (structure CASE). + * + * Elle prend en compte deux arguments, le plateau en dur et la fenetre olono + */ +void refreshBoard (CASE ** plateau) +{ + // Les variables locales de boucle : + gint n,i,j; + + for (i=0;icouleur) + { + case JOKER: + gtk_image_set_from_pixbuf (GTK_IMAGE(wOlono->pImage[n]), wOlono->imgJoker); + break; + + case BLANC: + gtk_image_set_from_pixbuf (GTK_IMAGE(wOlono->pImage[n]), wOlono->imgBlanche); + break; + + case NOIR: + gtk_image_set_from_pixbuf (GTK_IMAGE(wOlono->pImage[n]), wOlono->imgNoire); + break; + + case VIDE: + gtk_image_set_from_pixbuf (GTK_IMAGE(wOlono->pImage[n]), wOlono->imgVide); + break; + + default: + break; + } + } + } +} + +//! La fonction suivante sert à montrer les coups possibles sur le plateau actuel +/** + * Cette fonction liste et charge les images pour montrer les coups possibles + * pour la couleur donnée sur le plateau donné. + * Ces coups seront directement affichés avec un mépris non dissimulé pour cette + * piètre fonction de bête recopie qu'est refreshBoard(plateau). + */ +void montrerCoupsPossibles(char jeton, CASE ** plateau) +{ + int * listeValides; + int nbCoups,i,n; + + listeValides = (int *) malloc(taillePlateau*taillePlateau*sizeof(int)); + nbCoups = nbCoupsValides(jeton,plateau,listeValides); + + for (i=0;ipImage[n]), wOlono->imgTransBlanche); + break; + + case NOIR: + gtk_image_set_from_pixbuf (GTK_IMAGE(wOlono->pImage[n]), wOlono->imgTransNoire); + break; + } + } +} + + +//! Cette fonction se charge de jouer le tour de l'IA : +/** + * + */ +void joueTourIA (void) +{ + // On isole le plateau pendant que l'IA joue + gtk_grab_add(wOlono->pPlateau); + + int x=0,y=0; + char message[100]; + + sprintf(message,"%s joue. Calcul du coup ...", couleurIA ? "Noir" : "Blanc"); + + // On fait un pop/push pour éviter de remplir la pile. Et puis à qui + // elle sert cette *** de pile ? + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01)); + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01), message); + + // On force GTK a évaluer la situation : + gtk_main_iteration (); + + do + { + meilleurXY(plateau,couleurIA,&x,&y); + jouerCoup(x,y,couleurIA,plateau); + majHistorique(plateau,couleurIA); + + refreshBoard(plateau); + + // On force GTK a évaluer la situation : + gtk_main_iteration (); + + // Si le suivant a un coup, on le laisse jouer : + if (peutJouer(!couleurIA,plateau)) // PAS DE ; ! + break; + + // Si jamais on est en fin de partie ie personne ne peut jouer : + if (!peutJouer(jeton,plateau) && !peutJouer(!jeton,plateau)) + { + if (args.verbose) + ecrire("Fin de partie ...\n"); + score(plateau, points); + + if (points[BLANC] > points[NOIR]) + sprintf(message, "Fin de partie : les Blancs gagnent par %d contre %d.", + points[BLANC], points[NOIR]); + else if (points[NOIR] > points[BLANC]) + sprintf(message, "Fin de partie : les Noirs gagnent par %d contre %d.", + points[NOIR], points[BLANC]); + else + sprintf(message, "Fin de partie : match nul, %d partout.", points[BLANC]); + + // On nettoie la variable des scores immédiatement après son affichage : + // dans le cas d'un retour dans l'historique les points se trouvenet + // curiosement aditionnés sinon : + points[BLANC] = 0; + points[NOIR] = 0; + + // On fait un pop/push pour éviter de remplir la pile. Et puis à qui + // elle sert cette *** de pile ? + // Pour le contexte 1, a qui le tour : + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01)); + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01),""); + + // Pour le contexte 2, score : + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId02)); + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId02),message); + + // Et on enlève le grab apres que l'IA ai fini de jouer + gtk_grab_remove(wOlono->pPlateau); + + return; + } + } + while (1); + + jeton = !jeton; + + // L'ia a fini de jouer, elle nous montre nos coups : + (affJouable) ? montrerCoupsPossibles(jeton,plateau) : ""; + + sprintf(message,"À %s de jouer", jeton ? "Noir" : "Blanc"); + + // On fait un pop/push pour éviter de remplir la pile. Et puis à qui + // elle sert cette *** de pile ? + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01)); + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01), message); + + // Et on enlève le grab apres que l'IA ai fini de jouer + gtk_grab_remove(wOlono->pPlateau); +} + + +//! Cette fonction se charge de vider tout ce qui a été mallocé : +/** + * Cette fonction détruit toutes les références explicites en mémoire, + * par exemple, les pixbuf, les tableau mallocé, etc. + */ +void freeEverything (void) +{ + int i; + + for (i=0; iimgVide); + g_object_unref(wOlono->imgNoire); + g_object_unref(wOlono->imgBlanche); + g_object_unref(wOlono->imgJoker); + g_object_unref(wOlono->imgTransBlanche); + g_object_unref(wOlono->imgTransNoire); + + // Et les autres choses qui trainent encore + gtk_widget_destroy(wOlono->pPlateau); + gtk_widget_destroy(wOlono->pWindow); + + // Avant de freeer la structure wOlono + free(wOlono); +} + + + + + + + + + + + +/* + * ############################################################################# + * # PARTIE FONCTION DE CALLBACK : ############################################# + * ############################################################################# + */ + + +//! Callback : Clic sur le bouton "Précédent" +void on_boutonPrecedent_clicked (GtkWidget * widget, gpointer data) +{ + // On prépare la variable du texte message : + char message[100]; + + // Tant qu'on ne peut pas jouer on recule dans l'historique : + do + { + jeton = reculerHistorique(plateau); + } + while (!peutJouer(jeton,plateau)); + + // Pas d'oubli du user : + refreshBoard(plateau); + (affJouable) ? montrerCoupsPossibles(jeton,plateau) : ""; + + // On fait un pop/push pour éviter de remplir la pile. Et puis à quoi + // elle sert cette *** de pile ? + sprintf(message,"À %s de jouer", jeton ? "Noir" : "Blanc"); + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01)); + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01), message); +} + +void on_boutonSuivant_clicked (GtkWidget * widget, gpointer data) +{ + // De même que pour boutonPrecedent : + char message[100]; + + // Tant qu'on ne peut pas jouer on avance dans l'historique : + if (!peutJouer(jeton,plateau)) + jeton = !jeton; + + jeton = avancerHistorique(plateau); + + // Pas d'oubli du user : + refreshBoard(plateau); + (affJouable) ? montrerCoupsPossibles(jeton,plateau) : ""; + + // Si jamais on est en fin de partie ie personne ne peut jouer : + // Sinon on tombe en boucle infinie et ça c'est pas cool ... + if (!peutJouer(jeton,plateau) && !peutJouer(!jeton,plateau)) + { + score(plateau, points); + if (points[BLANC] > points[NOIR]) + sprintf(message, "Fin de partie : les Blancs gagnent par %d contre %d.", + points[BLANC], points[NOIR]); + else if (points[NOIR] > points[BLANC]) + sprintf(message, "Fin de partie : les Noirs gagnent par %d contre %d.", + points[NOIR], points[BLANC]); + else + sprintf(message, "Fin de partie : match nul, %d partout.", points[BLANC]); + + // On nettoie la variable des scores immédiatement après son affichage : + // dans le cas d'un retour dans l'historique les points se trouvenet + // curiosement aditionnés sinon : + points[BLANC] = 0; + points[NOIR] = 0; + + // On fait un pop/push pour éviter de remplir la pile. Et puis à qui + // elle sert cette *** de pile ? + // Pour le contexte 1, a qui le tour : + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01)); + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01),""); + + // Pour le contexte 2, score : + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId02)); + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId02),message); + + return; + } + //} while (!peutJouer(jeton,plateau)); + + // On fait un pop/push pour éviter de remplir la pile. Et puis à quoi + // elle sert cette *** de pile ? + sprintf(message,"À %s de jouer", jeton ? "Noir" : "Blanc"); + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01)); + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01), message); +} + +void on_menuBoutonNouvellePartie_activate (GtkWidget * widget, gpointer data) +{ + // On créé une variable locale pour un éventuel message en statusbar ; + char message[100]; + + // On réinitialise le plateau; + int i=0; + for (i=0;i<(taillePlateau*taillePlateau);i++) + { + plateau[i]->x = i / taillePlateau; + plateau[i]->y = i % taillePlateau; + plateau[i]->couleur = VIDE; + } + initPlateau(plateau); + + // On réinitialise les points : + points[BLANC] = 0; + points[NOIR] = 0; + + // On réinitialise aPuJouer[] : + aPuJouer[BLANC] = 1; + aPuJouer[NOIR] = 1; + + // On dégage les commentaires en statusBar : + // --- D'abord le message du score : + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId02)); + // --- Puis le dernier messages de tour : + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01)); + + // On charge les (éventuelles) nouvelles rêgles + couleurDepart = prefs.couleurDepart; + allowIA = prefs.allowIA; + couleurIA = prefs.couleurIA; + affJouable = prefs.affJouable; + //taillePlateau = prefs.taillePlateau; + /* On verra plus tard l'implémentation du changement de taille automatique */ + + // Et aussi l'historique : + endHistorique(); + tronc = initHistorique(plateau,couleurDepart); + + // Celui qui commence : + jeton = couleurDepart; + + + // On rafraichit l'affichage; + refreshBoard(plateau); + (affJouable) ? montrerCoupsPossibles(jeton,plateau) : ""; + + // Message Ready ! + (args.verbose) ? ecrire("Nouvelle partie !\n") : ""; + + sprintf(message,"Nouvelle partie, à %s de commencer", jeton ? "Noir" : "Blanc"); + + // On fait un pop/push pour éviter de remplir la pile. Et puis à qui + // elle sert cette *** de pile ? + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01)); + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01), message); + + // Si l'IA a le jeton, alors elle commence : + if (jeton == couleurIA) + joueTourIA(); +} + +//! Callback 1 +void on_menuBoutonQuitter_select (GtkWidget * widget, gpointer data) +{ + if (args.verbose) + ecrire("Nooooooon, ne quitte pas ce merveilleux programme.\n"); +} + +void on_menuBoutonQuitter_activate (GtkWidget * widget, gpointer data) +{ + if (args.verbose) + ecrire("Trop tard :(\n"); + freeEverything(); + endHistorique(); + gtk_main_quit(); +} + +void on_buttonAppliquer_activate (GtkWidget * widget, gpointer data) +{ + int nbBits = 0; + + // Enregistrons les préférences : + fichierPreferences = fopen(".olonoPrefs", "wb+"); + nbBits = fwrite(&prefs,sizeof(preferences),1,fichierPreferences); + + // On change dynamiquement ce qu'il est possible de changer : + allowIA = prefs.allowIA; + couleurIA = prefs.couleurIA; + affJouable = prefs.affJouable; + + (args.verbose) ? ecrire("Données enregistrées ! %d information écrite\n",nbBits):""; + + // Force la fermeture de la fenetre, comme glade est pas très fort pour ça : + gtk_widget_hide(wOlono->pPrefWindow); + gtk_main_iteration(); + + // Si l'IA a le jeton, vu qu'elle peut avoir changé de couleur, alors elle joue : + if (jeton == couleurIA) + joueTourIA(); +} + + +void on_case_clic (GtkWidget * widget, GdkEventButton *event, gpointer data) +{ + // Les cases sont inactives tant que l'IA joue + if (allowIA && jeton == couleurIA) + return; + + gchar message[100]; // Normalement on segfault pas avec ça. + + // On récupère un pointeur sur gint : + CASE * caseActuelle = (CASE*) data; + + // getting the position; + if (args.verbose) + { + ecrire("clicked at position : x:%d y:%d\n",caseActuelle->x,caseActuelle->y); + ecrire("Etat de aPuJouer : %d %d\n",aPuJouer[BLANC],aPuJouer[NOIR]); + } + + // Essaye de jouer le coup, et enregistre si oui ou non il est possible. + aPuJouer[jeton] = jouerCoup(caseActuelle->x,caseActuelle->y,jeton,plateau); + + // Si on a pas pu jouer : + if (!aPuJouer[jeton]) + { + if (args.verbose) + ecrire("Coup illégal pour %s\n", jeton ? "Noir" : "Blanc"); + return; + } + else + { + if (args.verbose) + { + ecrire("Coup légal pour %s\n", jeton ? "Noir" : "Blanc"); + } + refreshBoard(plateau); + + // On force GTK a évaluer la situation : + gtk_main_iteration (); + + } + + // Si jamais on est en fin de partie ie personne ne peut jouer : + if (!peutJouer(jeton,plateau) && !peutJouer(!jeton,plateau)) + { + // On oublie pas de mettre à jour l'historique, des fois que certains + // mécontent de leur mise à mort veuillent rejouer : + majHistorique(plateau,jeton); + + if (args.verbose) + ecrire("Fin de partie ...\n"); + score(plateau, points); + + if (points[BLANC] > points[NOIR]) + sprintf(message, "Fin de partie : les Blancs gagnent par %d contre %d.", + points[BLANC], points[NOIR]); + else if (points[NOIR] > points[BLANC]) + sprintf(message, "Fin de partie : les Noirs gagnent par %d contre %d.", + points[NOIR], points[BLANC]); + else + sprintf(message, "Fin de partie : match nul, %d partout.", points[BLANC]); + + // On nettoie la variable des scores immédiatement après son affichage : + // dans le cas d'un retour dans l'historique les points se trouvenet + // curiosement aditionnés sinon : + points[BLANC] = 0; + points[NOIR] = 0; + + // On fait un pop/push pour éviter de remplir la pile. Et puis à qui + // elle sert cette *** de pile ? + // Pour le contexte 1, a qui le tour : + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01)); + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01),""); + + // Pour le contexte 2, score : + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId02)); + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId02),message); + + return; + } + + // Si le suivant n'a pas de coup : + if (!peutJouer(!jeton,plateau)) + { + // On indique qu'il n'a pas pu jouer son tour, et on recommence le tour + // actuel + aPuJouer[!jeton] = 0; + + if (args.verbose) + ecrire("Encore a %s de jouer\n", jeton ? "Noir" : "Blanc"); + + (affJouable) ? montrerCoupsPossibles(jeton,plateau) : ""; + + sprintf(message,"Encore à %s de jouer", jeton ? "Noir" : "Blanc"); + + // On fait un pop/push pour éviter de remplir la pile. Et puis à qui + // elle sert cette *** de pile ? + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01)); + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01), message); + + // Mise à jour de l'historique de jeu, d'abord, le coup actuel de jeton, + // puis de l'autre !jeton qui n'a pas pu jouer. + majHistorique(plateau,jeton); + majHistorique(plateau,!jeton); + + return; + } + + // Si tout s'est déroulé normalement, on passe au joueur suivant : + majHistorique(plateau,jeton); + jeton = !jeton; + + if (args.verbose) + ecrire("A %s de jouer\n", jeton ? "Noir" : "Blanc"); + + sprintf(message,"À %s de jouer", jeton ? "Noir" : "Blanc"); + + // On fait un pop/push pour éviter de remplir la pile. Et puis à qui + // elle sert cette *** de pile ? + gtk_statusbar_pop (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01)); + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01), message); + + refreshBoard (plateau); + (affJouable) ? montrerCoupsPossibles(jeton,plateau) : ""; + + // On force GTK a évaluer la situation : + gtk_main_iteration (); + + /* **************************************** */ + /* AU TOUR DE L'IA, si elle peut jouer : */ + /* **************************************** */ + // On sort si l'IA est pas sensé jouer + if (!allowIA) + return; + + joueTourIA(); +} + + +void on_allowIA_toggled (GtkWidget * widget, gpointer data) +{ + // On active/désactive la case cochée selon les préférences en cours : + prefs.allowIA = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wOlono->pCheckAllowIA)); + args.verbose ? ecrire("%s de la propriété allowIA.\n", prefs.allowIA ? "Ajout" : "Retrait") : ""; +} + +void on_iaIsBlack_toggled (GtkWidget * widget, gpointer data) +{ + // On active/désactive la case cochée selon les préférences en cours : + prefs.couleurIA = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wOlono->pCheckiaIsBlack)); + args.verbose ? ecrire("L'ordinateur joue les %s.\n", prefs.couleurIA ? "Noirs" : "Blancs") : ""; +} + +void on_showPossibleMoves_toggled (GtkWidget * widget, gpointer data) +{ + // On active/désactive la case cochée selon les préférences en cours : + prefs.affJouable = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wOlono->pCheckAffJouable)); + args.verbose ? ecrire("%s de la propriété afficher coups jouables.\n", prefs.affJouable ? "Ajout" : "Retrait") : ""; +} + +void on_whiteStart_toggled (GtkWidget * widget, gpointer data) +{ + // On active/désactive la case cochée selon les préférences en cours : + prefs.couleurDepart = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wOlono->pCheckCouleurDeb)); + args.verbose ? ecrire("Les %s commencent.\n", prefs.couleurDepart ? "Noirs" : "Blancs") : ""; +} + +void on_taillePlateau_value_changed (GtkWidget * widget, gpointer data) +{ + prefs.taillePlateau = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (wOlono->pSpinTT)); + args.verbose ? ecrire("Valeur de taillePlateau fixée à %d.\n", prefs.taillePlateau) : "" ; +} + diff --git a/olono_X11/src/libGUI.h b/olono_X11/src/libGUI.h new file mode 100644 index 0000000..4dd6082 --- /dev/null +++ b/olono_X11/src/libGUI.h @@ -0,0 +1,85 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libGUI.h + * Contient les entêtes des fonctions de libGUI.c + */ + +/// Fichier de définition du package et des paths : +/// On pourra remplacer par un système de gestion dynamique de vérif, permettant de bouger le +/// programme sans le recompiler. Mais plus tard ... +#include "config.h" +#include "libCases.h" + +#define GLADEDIR "olono-gtk/glade" +#define GLADEFILE "olonoGUI.glade" +#define IMGDIR "olono-gtk/images" +#define IMGVIDE "olono_caseV.png" +#define IMGBLANCHE "olono_caseB.png" +#define IMGTBLANCHE "olono_caseTB.png" +#define IMGNOIRE "olono_caseN.png" +#define IMGTNOIRE "olono_caseTN.png" +#define IMGJOKER "olono_caseJ.png" + +typedef struct _WINDOW +{ + GtkWidget *pPlateau; + GtkWidget *pImage[625]; + GtkWidget *pEvent[625]; + GtkWidget *pWindow; + GtkWidget *pPrefWindow; + GtkWidget *pContainer; + GtkWidget *pStatusBar; + GtkWidget *pCheckAllowIA; + GtkWidget *pCheckiaIsBlack; + GtkWidget *pCheckAffJouable; + GtkWidget *pCheckCouleurDeb; + GtkWidget *pSpinTT; + GdkPixbuf *imgBlanche; + GdkPixbuf *imgTransBlanche; + GdkPixbuf *imgNoire; + GdkPixbuf *imgTransNoire; + GdkPixbuf *imgVide; + GdkPixbuf *imgJoker; + GError *gerror; + guint contextId01; + guint contextId02; +} window; + +// Fonctions de modification annexe : +void refreshBoard (CASE ** plateau); +void montrerCoupsPossibles (char couleur, CASE ** plateau); +void freeEverything (void); + +// Fonctions de callback : +void on_boutonPrecedent_clicked (GtkWidget * widget, gpointer data); +void on_boutonSuivant_clicked (GtkWidget * widget, gpointer data); +void on_menuBoutonNouvellePartie_activate (GtkWidget * widget, gpointer data); +void on_menuBoutonQuitter_select (GtkWidget * widget, gpointer data); +void on_menuBoutonQuitter_activate (GtkWidget * widget, gpointer data); +void on_case_clic (GtkWidget * widget, + GdkEventButton *event, gpointer data); +void on_allowIA_toggled (GtkWidget * widget, gpointer data); +void on_iaIsBlack_toggled (GtkWidget * widget, gpointer data); +void on_showPossibleMoves_toggled (GtkWidget * widget, gpointer data); +void on_whiteStart_toggled (GtkWidget * widget, gpointer data); +void on_taillePlateau_value_changed (GtkWidget * widget, gpointer data); + diff --git a/olono_X11/src/libIA-dumb.c b/olono_X11/src/libIA-dumb.c new file mode 100644 index 0000000..44cfed5 --- /dev/null +++ b/olono_X11/src/libIA-dumb.c @@ -0,0 +1,162 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include +#include +#include "libDefine.h" +#include "libIA.h" +#include "libPlay.h" +#include "libDisplay.h" // Pour les messages de debug + +extern int taillePlateau; +extern arguments args; + +//! Place les meilleures coordonnées dans x et y +int meilleurXY(CASE *plateau[], char couleur, int * x, int * y) +{ + NOEUD noeud; // On crée le noeud-père + noeud.couleur = !couleur; // C'est l'adversaire qui vient de jouer + + // On récupère ici la valeur du plateau. + // On ne s'en sert actuellement pas mais bon... + int valeur = minmax(plateau, &noeud, 6, -INFINI, INFINI); + if (args.verbose) + erreur("Veleur supposée du coup: %d\n", valeur); + + // On récupère les coordonnées du meilleur coup directement fils + *x = noeud.meilleurX; + *y = noeud.meilleurY; + + return 0; +} + +//! Calcule l'arbre des possibilités et renvoie la valeur du noeud en cours +/** + * Implémentation de l'algorithme Minimax + * S'appelle récursivement pour calculer la valeur d'un noeud à partir des + * noeuds fils. + * Si un noeud est terminal, sa valeur est sa valeur heuristique (pour le + * moment, c'est tout simplement le différentiel de score. Il n'y a pas de + * fonction heuristique). Sinon, elle est égale à la plus basse valeur des + * fils. (Grâce à la simplification Negamax, pas besoin d'alterner entre plus + * bas et plus haut selon qu'on est sur un noeud ennemi ou allié). + * A venir: heuristique; élagage + */ +int minmax(CASE *plateau[], NOEUD * noeud, int profondeur, int alpha, int beta) +{ + if (profondeur <= 0) // Si on est un noeud terminal on renvoie la valeur du plateau + { + int points[] = {0, 0}; + score(plateau, points); // Pour le moment, il n'y a pas de fonction heuristique, on prend le score brut + return points[(int) noeud->couleur] - points[(int) !(noeud->couleur)]; // Valeur du noeud; + } + + int index; + int i, j; + int * listeValides = malloc(taillePlateau * taillePlateau * sizeof(int)); + + // On calcule le nombre de fils et on alloue la liste des fils en + // onséquence. + noeud->nbDeFils = nbCoupsValides(!(noeud->couleur), plateau, listeValides); + //if (noeud->nbDeFils > 2) + // noeud->nbDeFils = 2; + if (noeud->nbDeFils) + noeud->listeFils = calloc(noeud->nbDeFils, sizeof(NOEUD *)); // calloc met la mémoire à 0 + else + noeud->listeFils = malloc(1*sizeof(NOEUD)); // Si le joueur ne peut pas jouer, il passe: 1 noeud + + for(i=0; i<(noeud->nbDeFils); i++) + { + // On alloue le noeud fils + (noeud->listeFils)[i] = malloc(sizeof(NOEUD)); + NOEUD * fils = (noeud->listeFils)[i]; + fils->listeFils = NULL; + fils->nbDeFils = 0; + + // On crée une copie de travail du plateau + // (Très consommateur de mémoire) + fils->plateau = copiePlateau(plateau); + + // On calcule ses coordonnées + fils->x = listeValides[i]/taillePlateau; + fils->y = listeValides[i]%taillePlateau; + fils->couleur = !(noeud->couleur); + + // On simule le coup sur la copie + jouerCoup(fils->x, fils->y, fils->couleur, fils->plateau); + + // Convention Negamax + fils->valeur = -minmax(fils->plateau, fils, profondeur-1, -beta, -alpha); + + // Libérez la mémoire! Libérez la mémoire! + for(j=0; j<(taillePlateau*taillePlateau); j++) + free(fils->plateau[j]); + free(fils->plateau); + + // Coupure alpha/beta: + if (fils->valeur > alpha) + { + noeud->meilleurX = fils->x; + noeud->meilleurY = fils->y; + alpha = fils->valeur; + index = i; + if (alpha >= beta) + { + //On élague ! + break; + } + } + } + + if (noeud->nbDeFils == 0) // Je ne peux pas jouer + { + noeud->nbDeFils = 1; // J'ai donc une seule branche: passer + + (noeud->listeFils)[0] = malloc(sizeof(NOEUD)); + NOEUD * fils = (noeud->listeFils)[0]; + fils->listeFils = NULL; + fils->nbDeFils = 0; + fils->plateau = copiePlateau(plateau); + + fils->couleur = !(noeud->couleur); + fils->x = -1; // Inutile pour le moment + fils->y = -1; + + // Je saute donc l'étape "jouer le coup" + // Et je calule la valeur des fils + fils->valeur = -minmax(fils->plateau, fils, profondeur-1, -beta, -alpha); + alpha = fils->valeur; + for(j=0; j<(taillePlateau*taillePlateau); j++) + free(fils->plateau[j]); + free(fils->plateau); + } + + + // Le Front de Libération de la Mémoire intervient + + free(listeValides); + + for(i=0; i<(noeud->nbDeFils); i++) + free((noeud->listeFils)[i]); + free(noeud->listeFils); + + return alpha; +} + diff --git a/olono_X11/src/libIA.c b/olono_X11/src/libIA.c new file mode 100644 index 0000000..69fe5e7 --- /dev/null +++ b/olono_X11/src/libIA.c @@ -0,0 +1,366 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include +#include +#include "libDefine.h" +#include "libIA.h" +#include "libPlay.h" +#include "libDisplay.h" // Pour les messages de debug + +extern int taillePlateau; +extern arguments args; + +//! Place les meilleures coordonnées dans x et y +int meilleurXY(CASE *plateau[], char couleur, int * x, int * y) +{ + NOEUD noeud; // On crée le noeud-père + noeud.couleur = !couleur; // C'est l'adversaire qui vient de jouer + + // On récupère ici la valeur du plateau. + // On ne s'en sert actuellement pas mais bon... + int valeur = minmax(plateau, &noeud, 6, -INFINI, INFINI); + if (args.verbose) + erreur("Veleur supposée du coup: %d\n", valeur); + + // On récupère les coordonnées du meilleur coup directement fils + *x = noeud.meilleurX; + *y = noeud.meilleurY; + + if (args.verbose) + erreur("Valeur de la case: %d\n", valeurCase(*x, *y)); + + return 0; +} + +//! Calcule l'arbre des possibilités et renvoie la valeur du noeud en cours +/** + * Implémentation de l'algorithme Minimax + * S'appelle récursivement pour calculer la valeur d'un noeud à partir des + * noeuds fils. + * Si un noeud est terminal, sa valeur est sa valeur heuristique (pour le + * moment, c'est tout simplement le différentiel de score. Il n'y a pas de + * fonction heuristique). Sinon, elle est égale à la plus basse valeur des + * fils. (Grâce à la simplification Negamax, pas besoin d'alterner entre plus + * bas et plus haut selon qu'on est sur un noeud ennemi ou allié). + * A venir: heuristique; élagage + */ +int minmax(CASE *plateau[], NOEUD * noeud, int profondeur, int alpha, int beta) +{ + if (profondeur <= 0) // Si on est un noeud terminal on renvoie la valeur du plateau + { + int score = valeurPlateau(!noeud->couleur, plateau); + return score; + } + + int index; + int i, j; + int * listeValides = malloc(taillePlateau * taillePlateau * sizeof(int)); + + // On calcule le nombre de fils et on alloue la liste des fils en + // onséquence. + noeud->nbDeFils = nbCoupsValides(!(noeud->couleur), plateau, listeValides); + //if (noeud->nbDeFils > 2) + // noeud->nbDeFils = 2; + if (noeud->nbDeFils) + noeud->listeFils = calloc(noeud->nbDeFils, sizeof(NOEUD *)); // calloc met la mémoire à 0 + else + noeud->listeFils = malloc(1*sizeof(NOEUD)); // Si le joueur ne peut pas jouer, il passe: 1 noeud + + for(i=0; i<(noeud->nbDeFils); i++) + { + // On alloue le noeud fils + (noeud->listeFils)[i] = malloc(sizeof(NOEUD)); + NOEUD * fils = (noeud->listeFils)[i]; + fils->listeFils = NULL; + fils->nbDeFils = 0; + + // On crée une copie de travail du plateau + // (Très consommateur de mémoire) + fils->plateau = copiePlateau(plateau); + + // On calcule ses coordonnées + fils->x = listeValides[i]/taillePlateau; + fils->y = listeValides[i]%taillePlateau; + fils->couleur = !(noeud->couleur); + + // On simule le coup sur la copie + jouerCoup(fils->x, fils->y, fils->couleur, fils->plateau); + + // Convention Negamax + fils->valeur = -minmax(fils->plateau, fils, profondeur-1, -beta, -alpha); + + // Libérez la mémoire! Libérez la mémoire! + for(j=0; j<(taillePlateau*taillePlateau); j++) + free(fils->plateau[j]); + free(fils->plateau); + + // Coupure alpha/beta: + if (fils->valeur > alpha) + { + noeud->meilleurX = fils->x; + noeud->meilleurY = fils->y; + alpha = fils->valeur; + index = i; + if (alpha >= beta) + { + //On élague ! + break; + } + } + } + + if (noeud->nbDeFils == 0) // Je ne peux pas jouer + { + noeud->nbDeFils = 1; // J'ai donc une seule branche: passer + + (noeud->listeFils)[0] = malloc(sizeof(NOEUD)); + NOEUD * fils = (noeud->listeFils)[0]; + fils->listeFils = NULL; + fils->nbDeFils = 0; + fils->plateau = copiePlateau(plateau); + + fils->couleur = !(noeud->couleur); + fils->x = -1; // Inutile pour le moment + fils->y = -1; + + // Je saute donc l'étape "jouer le coup" + // Et je calule la valeur des fils + fils->valeur = -minmax(fils->plateau, fils, profondeur-1, -beta, -alpha); + alpha = fils->valeur; + for(j=0; j<(taillePlateau*taillePlateau); j++) + free(fils->plateau[j]); + free(fils->plateau); + } + + + // Le Front de Libération de la Mémoire intervient + + free(listeValides); + + for(i=0; i<(noeud->nbDeFils); i++) + free((noeud->listeFils)[i]); + free(noeud->listeFils); + + return alpha; +} + +int valeurPlateau(char couleur, CASE *plateau[]) +{ + int i; + + int scorePondere[2]={0, 0}, scoreMobilite[2]={0, 0}, + scoreLignes[2]={0, 0}, scoreBrut[2]={0, 0}; + + float totalLignes=0, totalMobilite=0, + totalBrut=0, totalPondere=0; + + int fPondere , fMobilite, + fLignes, fBrut; // les facteur qui viennent ponderer les scores + /* + * La mobilite prend plus d'importance au fur et a mesure qu'on avance dans + * le jeu, idem pour le score brut mais l'importance vient plus + * progressivement + * + * Le score pondéré prend de l'importance en milieu de jeu et en perd au + * fur et à mesure + * + * Le score des lignes prend de l'importance en milieu de jeu et en gagne + * petit a petit, mais jamais trop + * + * Le score brut prend de l'importance tardivement mais devient presque la + * seule vers la fin + */ + + + /* * * * *\ + BRUT + \* * * * */ + + score(plateau, scoreBrut); + if (scoreBrut[BLANC] + scoreBrut[NOIR] > 0) // Au moins un joueur a des lignes + { + // Le total est la proportion des points qu'a le joueur + totalBrut = proportion((float) scoreBrut[(int) couleur], (float) scoreBrut[(int) !couleur]); + fBrut = 1; + } + else // Personne n'a de ligne + { + fBrut = 0; + } + //erreur("Total Brut: %f\n", totalBrut); + + + /* * * * *\ + PONDERE + \* * * * */ + + for (i=0; icouleur; + if (contenu == BLANC || contenu == NOIR) + scorePondere[(int) contenu] += valeurCase(x, y); + //erreur("Valeur de la case %d,%d: %d\n", x, y, valeurCase(x, y)); + } + if (scoreBrut[BLANC] + scoreBrut[NOIR] > 0) // Au moins un joueur a des lignes + { + // Le total est la proportion des points qu'a le joueur + totalPondere = proportion((float) scorePondere[(int) couleur], (float) scorePondere[(int) !couleur]); + fPondere = 5; + } + else // Personne n'a de ligne + { + fPondere = 0; + } + //erreur("Total pondéré:%f\n", totalPondere); + + + /* * * * *\ + LIGNES + \* * * * */ + + for(i=0; i0) + scoreLignes[(int) couleur] += lin; + else + scoreLignes[(int) !couleur] -= lin; + + if (col>0) + scoreLignes[(int) couleur] += col; + else + scoreLignes[(int) !couleur] -= col; + } + if (scoreLignes[BLANC] + scoreLignes[NOIR] > 0) // Au moins un joueur a des lignes + { + // Le total est la proportion des points qu'a le joueur + totalLignes = proportion((float) scoreLignes[(int) couleur], (float) scoreLignes[(int) !couleur]); + fLignes = 1.5; + //erreur("Total Lignes:%f\n", totalLignes); + } + else // Personne n'a de ligne + { + fLignes = 0; + } + + /* * * * *\ + MOBILITE + \* * * * */ + int * temp = malloc(taillePlateau*taillePlateau*sizeof(int)); + scoreMobilite[BLANC] = nbCoupsValides(BLANC, plateau, temp); + scoreMobilite[NOIR] = nbCoupsValides(NOIR, plateau, temp); + free(temp); + if (scoreMobilite[BLANC] + scoreMobilite[NOIR] > 0) + { + totalMobilite = proportion((float) scoreMobilite[(int) couleur], (float) scoreMobilite[(int) !couleur]); + fMobilite = 2; + } + else + { + fMobilite = 0; + } + + int retour = 100 * ((totalPondere*fPondere) + + (totalBrut*fBrut) + + (totalLignes*fLignes) + + (totalMobilite*fMobilite)) / + (fPondere+fBrut+fLignes+fMobilite); + + //erreur("Valeur du plateau suivant:%d", retour); + //affichePlateau(plateau); + + return retour; +} + +int valeurColonne(int colonne, char couleur, CASE *plateau[]) +{ + int pions[4] = {0, 0, 0, 0}; // Seuls les deux premieres cases seront lues. + // En avoir 4 permet seulement d'avoir moins + // de tests + int i; + + for (i=0; icouleur])++; + + if (pions[(int) couleur] + pions[JOKER] >= taillePlateau-1) // La colonne est au joueur: Il a toute la colonne (sauf éventuellement un point) + return max(1, abs( (taillePlateau/2) - colonne)); // sans le max, renverrait 0 pour la colonne du milieu... + + // On renvoie un négatif si c'est l'ennemi + if (pions[!couleur] + pions[JOKER] >= taillePlateau-1) + return - max(1, abs( (taillePlateau/2) - colonne)); + + return 0; +} + +int valeurLigne(int ligne, char couleur, CASE *plateau[]) +{ + int pions[4] = {0, 0, 0, 0}; // Seuls les deux premieres cases seront lues. + // En avoir 4 permet seulement d'avoir moins + // de tests + int i; + + for (i=0; icouleur])++; + + if (pions[(int) couleur] + pions[JOKER] >= taillePlateau-1) // La ligne est au joueur: Il a toute la ligne (sauf éventuellement un point) + return max(1, abs( (taillePlateau/2) - ligne)); // sans le max, renverrait 0 pour la ligne du milieu... + + // On renvoie un négatif si c'est l'ennemi + if (pions[!couleur] + pions[JOKER] >= taillePlateau-1) + return - max(1, abs( (taillePlateau/2) - ligne)); + + return 0; +} + +int valeurCase(int x, int y) +{ + x = min(x, taillePlateau-x-1); + y = min(y, taillePlateau-y-1); + if (x > 1 && y > 1) // On est au milieu du plateau + return 40*(x+y)*taillePlateau; + + if (x == 1 || y == 1) // On est sur l'avant dernière ligne + { + if (x==y) // On est en diagonale du coin + return 0; // La plus basse valeur + if (x==0 || y==0) // On est sur un bord, à coté d'un coin + return 50*taillePlateau; + // Sinon: + return 150*taillePlateau; + } + + if (x == 0 || y == 0) // On est sur un bord, mais pas a coté du coin + { + if (x==y) // On est sur le coin !!! + return 3500*taillePlateau; + // Sinon, on est juste sur un bord: + return 600*taillePlateau; + } + + if (args.verbose) + erreur("PAS GLOP!!!!\n"); + return 0; + +} + diff --git a/olono_X11/src/libIA.h b/olono_X11/src/libIA.h new file mode 100644 index 0000000..65e9a91 --- /dev/null +++ b/olono_X11/src/libIA.h @@ -0,0 +1,34 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef _LIB_IA_H +#define _LIB_IA_H + +#include "libCases.h" + +int meilleurXY(CASE *plateau[], char couleur, int * x, int * y); +int minmax(CASE *plateau[], NOEUD * noeud, int profondeur, int alpha, int beta); +int valeurPlateau(char couleur, CASE *plateau[]); +int valeurCase(int x, int y); +int valeurLigne(int ligne, char couleur, CASE *plateau[]); +int valeurColonne(int colonne, char couleur, CASE *plateau[]); + +#endif + diff --git a/olono_X11/src/libPlay.c b/olono_X11/src/libPlay.c new file mode 100644 index 0000000..d4c6f1d --- /dev/null +++ b/olono_X11/src/libPlay.c @@ -0,0 +1,686 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libPlay.c + * Librairie indépendante du mode d'affichage. + * Elle gère toutes les règles du jeu et s'occupe d'effectuer les mouvements + * comme les retournements de pions. + */ + +#include +#include +#include "libPlay.h" +#include "libDefine.h" +#include "libDisplay.h" +#include "libIA.h" + +static int elaguer(NOEUD * noeud); + +static NOEUD tronc; // Le plateau d'origine +static NOEUD * actuel; // Pointe en permanence sur le plateau en cours + +extern int taillePlateau; + +//! Renvoie 0 si le coup n'est pas valide, le nombre de pièces qu'il retourne sinon. +/** + * Cette fonction renvoie le nombre de pièces à retourner et met les + * coordonnées des pièces à retourner dans le pointeur listeCoups. + * + * La liste increments contient les vecteurs selon lesquels parcourir le + * tableau: on suit toutes les droites et diagonales (première boucle for). + * Au début de chaque vecteur, on vérifie qu'on reste dans la plateau, que + * la case immédiatement n'est ni vide ni de la couleur du joueur. Dans le + * cas contraire, on passe immédiatement au vecteur suivant. + * Une fois ces prérequis vérifiés, on parcourt la suite du vecteur à la + * recherche d'une pierre amie (le while). On met les coordonnées des pions + * qui se trouvent sur le chemin. Si on trouve effectivement une pierre amie, + * le compteur total de pion à retourner est incrémenté. + * coupsTemp permet, si on ne rencontre pas d'amie, de ne pas fausser le compte + * de coups + * + * A tout moment, si on rencontre un joker, on le saute, c'est à dire qu'on + * fait un continue. +*/ +char lister(int x,int y,char couleur,CASE *plateau[], int listeCoups[]) +{ + CASE caseDepart; + char increments[8][2] = + { + {-1, -1}, + {-1, 0}, + {-1, 1}, + { 0, 1}, + { 1, 1}, + { 1, 0}, + { 1, -1}, + { 0, -1} + }; // Liste des vecteurs + int inc=0; // Parcourt les vecteurs + int coups=0, coupsTemp; // Compteur de nombre de pions retournés + char rencontre = 0; + + caseDepart = *adresseParXY(x, y, plateau); + + if (caseDepart.couleur != VIDE) + return 0; + + // On parcourt les vecteurs + for (inc=0; inc<8; inc++) + { + char incX=increments[inc][0], incY=increments[inc][1]; + char couleurCase; + CASE * caseTemp; + + caseTemp = caseSuivante(caseDepart, incX, incY, plateau); + // Si on est au bord du plateau ou s'il y a eu une erreur + if (caseTemp == NULL) + continue; + // Si on tombe ensuite sur une case de la meme couleur ou vide, on saute + if ( (caseTemp->couleur == couleur) || (caseTemp->couleur == VIDE) ) + continue; + + // Dans les autres cas, on continue d'incrementer + coupsTemp=1; // On retourne potentiellement 1 pion + // On l'ajoute à la liste des coups + listeCoups[coups] = (caseTemp->x)*taillePlateau + caseTemp->y; + while (1) // Pas besoin de vérification puisqu'on sort avec un break + { + caseTemp = caseSuivante(*caseTemp, incX, incY, plateau); + if (caseTemp == NULL) + break; // Il y a pas de case suivante. On est arrivé au bord sans trouver d'ami + couleurCase = caseTemp->couleur; + + // Si on tombe sur le joker, on passe cette case: + if (couleurCase == JOKER) + { + continue; + } + // Case Vide, Stop: + if (couleurCase == VIDE) + { + break; + } + // Si on tombe sur un ami: + if (couleurCase == couleur) + { + rencontre = 1; + break; // On a trouve qqn et on a rentre les coups. On passe au vecteur suivant + } + // On est tombé sur un ennemi, on l'ajoute + listeCoups[coups + (coupsTemp++)] = (caseTemp->x)*taillePlateau + caseTemp->y; + } + if (rencontre) + coups += coupsTemp; + coupsTemp = 0; + rencontre = 0; + } + + return coups; +} + +//! Renvoie 1 si le coup est valide, 0 pour invalide +char valide(int x, int y, char couleur, CASE *plateau[]) +{ + CASE caseDepart; + char increments[8][2] = + { + {-1, -1}, + {-1, 0}, + {-1, 1}, + { 0, 1}, + { 1, 1}, + { 1, 0}, + { 1, -1}, + { 0, -1} + }; // Liste des vecteurs + int inc=0; // Parcourt les vecteurs + char rencontre = 0; + + caseDepart = *adresseParXY(x, y, plateau); + + if (caseDepart.couleur != VIDE) + return 0; + + // On parcourt les vecteurs + for (inc=0; inc<8; inc++) + { + char incX=increments[inc][0], incY=increments[inc][1]; + char couleurCase; + CASE * caseTemp; + + caseTemp = caseSuivante(caseDepart, incX, incY, plateau); + // Si on est au bord du plateau ou s'il y a eu une erreur + if (caseTemp == NULL) + continue; + // Si on tombe ensuite sur une case de la meme couleur ou vide, on saute + if ( (caseTemp->couleur == couleur) || (caseTemp->couleur == VIDE) ) + continue; + + // Dans les autres cas, on continue d'incrementer + do + { + caseTemp = caseSuivante(*caseTemp, incX, incY, plateau); + if (caseTemp == NULL) + break; // Il y a pas de case suivante. On est arrivé au bord sans trouver d'ami + couleurCase = caseTemp->couleur; + + // Si on tombe sur le joker, on passe cette case: + if (couleurCase == JOKER) + continue; + // Case Vide, Stop: + else if (couleurCase == VIDE) + break; + // On a trouvé un pote ! + else if (couleurCase == couleur) + rencontre = 1; + } while(!rencontre); + if (rencontre) + return 1; // Au moins 1 vecteur + } + return 0; // Rien trouvé: pas valide +} + +//! Renvoie le nombre de coups valides +char nbCoupsValides(char couleur, CASE *plateau[], int listeValides[]) +{ + char i, j; + int coups=0; + + for(i=0; icouleur; + + // Le reste est tout con + if (couleur == BLANC) + couleur = NOIR; + // Important tout de même de else if, sinon ça ne marche pas. + else if (couleur == NOIR) + couleur = BLANC; + // Si c JOKER VIDE ou quoi que ce soit d'autre on se casse, c'est pas notre boulot. + else + return; + caseARetourner->couleur = couleur; +} + +//! Joue le tour actuel si possible. +/** + * Cette fonction, appelée par le main, joue le tour d'un joueur passé + * en argument. S'il y a lieu, il retourne les pions et place le pion du + * joueur. + * Elle renvoie ensuite le nombre de pièces retournées. + * Donc si le joueur ne peut pas jouer, la fonction ne fait rien et renvoie 0. + */ +int peutJouer(char couleur, CASE *plateau[]) +{ + int i, j; + + // On cherche s'il existe au moins 1 coup possible + for (i=0; icouleur = couleur; // On pose le pion + + free(listeCoups); + return nbCoups; +} + +//! Teste la fin de partie. +/** + * La partie se finit si le plateau est rempli ou si un joueur n'as plus de + * pièces sur le plateau (Là, il l'a mauvaise). Dans ce cas cette fonction renvoi 1. + * Tant que la partie n'est pas finie, cette fonction renvoi 0 + */ +int testFinPartie(CASE *plateau[]) +{ + int i, j; + int unicolore=1, plein=1; + char couleur[2] = {0, 0}; + + for (i=0; icouleur == BLANC) + { + points[0]++; + } + else if (adresseParXY(i, j, plateau)->couleur == NOIR) + { + points[1]++; + } + } + } +} + +//! Renvoit un simple pointeur comme tableau multidim +/** + * Crée et envoie une liste de pointeurs qui représente le tableau. + * Le pointeur renvoyé représente les colonne et chaque pointeur dans cette + * liste est une ligne. Le tableau renvoyé est initialisé à VIDE. +*/ +CASE ** createPlateau() +{ + // On crée une liste de pointeurs sur les cases + CASE ** plateau = malloc(taillePlateau * taillePlateau * sizeof(CASE *)); + //erreur("Création d'un plateau à l'adresse %p\n", plateau); + // On crée maintenant chaque case, et on met son pointeur dans la liste + int i=0; + for (i=0;i<(taillePlateau*taillePlateau);i++) + { + plateau[i] = malloc(sizeof(CASE)); + plateau[i]->x = i / taillePlateau; + plateau[i]->y = i % taillePlateau; + plateau[i]->couleur = VIDE; + } + + // Cette fonction renvoit un pointeur sur le plateau + // pour modif et affichage ultérieur. + return plateau; +} + +//! Copie un plateau passé en argument. utilise taillePlateau +CASE ** copiePlateau(CASE *plateau[]) +{ + CASE ** copie = malloc(taillePlateau * taillePlateau * sizeof(CASE *)); + //erreur("Copie du plateau %p en %p\n", plateau, copie); + int i; + for(i=0; i<(taillePlateau*taillePlateau); i++) + { + copie[i] = malloc(sizeof(CASE)); + copie[i]->x = i / taillePlateau; + copie[i]->y = i % taillePlateau; + copie[i]->couleur = adresseParXY(copie[i]->x, copie[i]->y, plateau)->couleur; + } + return copie; +} + +//! Rempli le centre d'un tableau passé en argument +/** + * Initialise la partie en ajoutant au tableau vide le carré central donné + * en consigne. Il contient un Joker en son centre. +*/ +void initPlateau(CASE *plateau[]) +{ + // Le motif donné par la consigne : + char motif[9]; + if (taillePlateau % 2 == 1) // Plateau Impair + { + // La position de début du motif est à : + int debut = (taillePlateau/2)-1; + + motif[0] = BLANC; motif[1] = NOIR; motif[2] = BLANC; + motif[3] = BLANC; motif[4] = JOKER; motif[5] = NOIR; + motif[6] = NOIR; motif[7] = BLANC; motif[8] = NOIR; + + int i=0,j=0; + for (i=0;i<3;i++) + { + for (j=0;j<3;j++) + { + adresseParXY(debut+i, debut+j, plateau)->couleur = motif[j*3+i]; + } + } + } + else + { + // La position de début du motif est à : + int debut = (taillePlateau/2)-1; + + motif[0] = BLANC; motif[1] = NOIR; + motif[2] = NOIR; motif[3] = BLANC; + + int i=0,j=0; + for (i=0;i<2;i++) + { + for (j=0;j<2;j++) + { + adresseParXY(debut+i, debut+j, plateau)->couleur = motif[j*2+i]; + } + } + } + +} + +//! Trouve un coup et l'envoit +/** + * Fait appel à la libIA pour trouver le meilleur coup dans la position donnée + * Envoit ensuite le coup via la libDisplay (ecrire()) + */ +int jouerSonTour(char couleur, CASE *plateau[]) +{ + int x, y; + int retour; + + //erreur("On afiche le plateau que reçoit l'IA:\n"); + affichePlateau(plateau); + + if (!peutJouer(couleur, plateau)) + { + retour = meilleurXY(plateau, couleur, &x, &y); + pasDeCoup(); + //erreur("L'IA ne peut pas jouer\n"); + return 1; + } + else + { + retour = meilleurXY(plateau, couleur, &x, &y); // Trouve le meilleur coup + if (retour) + return -1; // Erreur ! + + envoyerXY(x, y); + retour = jouerCoup(x, y, couleur, plateau); + if (retour == 0) + return -1; // Erreur comise + } + + return 0; // Tout s'est bien déroulé +} + +//! Lit le coup adverse et le joue +/** + * Via la libDisplay, on lit le coup adverse (lireCoup()) + * Puis on le joue. S'il est illégal, on retourne un erreur. + */ +int jouerTourAdverse(char couleur, CASE *plateau[]) +{ + int retour; + char x; + int y; + + retour = lireCoup(&x, &y); + if (retour == 0) // L'adversaire a joué + { + retour = jouerCoup(x, y, !couleur, plateau); + if (retour == 0) // Aucun pion retourné + return -1; // L'adversaire a joué un coup illégal + } + else if (retour == 1) + return 1; // L'adversaire n'avait pas de coup} + + return 0; // L'adversaire a joué correctement +} + +//! Joue le tour actuel si possible. +/** + * Cette fonction, appelée par le main, joue le tour d'un joueur passé + * en argument. S'il y a lieu, il retourne les pions et place le pion du + * joueur. + * Elle renvoie ensuite le nombre de pièces retournées. + * Donc si le joueur ne peut pas jouer, la fonction ne fait rien et renvoie 0. + */ +int jouerTourSimple(char couleur, CASE *plateau[]) +{ + int nbCoups=0; + int coords[2] = {0, 0}; + + // On cherche s'il existe au moins 1 coup possible + if(!peutJouer(couleur, plateau)) + return 0; // Le joueur ne peut pas jouer + + // On demande le coup du joueur + do + { + demanderXY(coords); + nbCoups = jouerCoup(coords[0], coords[1], couleur, plateau); + } + while (nbCoups == 0); + + return nbCoups; +} + +//! Initialise l'historique avec le plateau/tronc +/** + * Après cette fonction, le tronc contient le plateau de départ + * (On peut partir avec un plateau de partie déjà en cours) + * Et actuel pointe sur le tronc + */ +NOEUD * initHistorique(CASE *plateau[], char couleur) +{ + tronc.nbDeFils = 0; + tronc.listeFils = NULL; + tronc.plateau = copiePlateau(plateau); + tronc.couleur = !couleur; + tronc.pere = NULL; + + actuel = &tronc; + + return &tronc; +} + +//! ajoute un fils au noeud actuel +/** + * L'historique supporte les variantes: un noeud peut avoir plusieurs fils + * Cette fonction retourne un pointeur vers le noeud crée + */ +NOEUD * majHistorique(CASE *plateau[], char couleur) +{ + NOEUD * fils = malloc(sizeof(NOEUD)); + fils->nbDeFils = 0; + fils->listeFils = NULL; + fils->plateau = copiePlateau(plateau); + fils->couleur = couleur; + fils->pere = actuel; + + // TODO : Si le fils existe déjà, il faut pas le recrée + + ajouteFils(actuel, fils); + + actuel = fils; + return actuel; // On informe le programme de l'emplacement du nouveau noeud +} + +//! Libère les noeuds de l'historique +void endHistorique() +{ + int j; + elaguer(&tronc); // On passe du désherbant hyperpuissant + + for (j=0; j<(taillePlateau*taillePlateau); j++) + free(tronc.plateau[j]); + free(tronc.plateau); +} + +//! renvoie la couleur du joueur dont c'est le tour +/** + * Fais pointer actuel sur son propre père. + * Recopie ensuite le plateau du noeud actuel dans le plateau passé en + * argument. + * Renvoie BLANC si on est au tronc; l'inverse de la couleur du plateau sinon. + */ +char reculerHistorique(CASE * plateau[]) +{ + if (actuel->pere != NULL) + { + actuel = actuel->pere; + + int j; + for (j=0; jplateau[j]); + } + + return !(actuel->couleur); +} + +//! renvoie la couleur du joueur dont c'est le tour +/** + * Fais pointer actuel sur le noeud passé en argument + * Recopie ensuite le plateau du noeud actuel dans le plateau passé en + * argument. + * Renvoie BLANC si on est au tronc; l'inverse de la couleur du plateau sinon. + */ +char sauterHistorique(CASE * plateau[], NOEUD * destination) +{ + + if (destination == NULL) + return -1; + + int j; + actuel = destination; + for (j=0; jplateau[j]); + + return !(actuel->couleur); +} + +//! renvoie la couleur du joueur dont c'est le tour +/** + * Fais pointer actuel sur son premier fils + * Recopie ensuite le plateau du noeud actuel dans le plateau passé en + * argument. + * Renvoie BLANC si on est au tronc; l'inverse de la couleur du plateau sinon. + */ +char avancerHistorique(CASE * plateau[]) +{ + if (actuel->nbDeFils <= 0 || actuel->listeFils == NULL) + return (actuel->couleur == VIDE) ? BLANC : !(actuel->couleur); + + actuel = actuel->listeFils[actuel->nbDeFils - 1]; + + int j; + for (j=0; jplateau[j]); + + return !(actuel->couleur); +} + +//! Ajoute un fils à la liste d'un noeud +/** + * Utilise realloc pour agrandir la liste du pere(premier argument) et + * ajoute un pointeur vers le fils(2ème argument) à la liste. + */ +void ajouteFils(NOEUD * pere, NOEUD * fils) +{ + (pere->nbDeFils)++; + // On étend la liste + pere->listeFils = realloc(pere->listeFils, pere->nbDeFils * sizeof(NOEUD *)); + + pere->listeFils[pere->nbDeFils - 1] = fils; +} + +//! libère tout les fils d'un noeud +static int elaguer(NOEUD * noeud) +{ + int i, j; + for (i=0; inbDeFils; i++) + { + NOEUD * fils = noeud->listeFils[i]; + if (fils->listeFils != NULL) // Ce fils a des fils, donc appel récursif de cette fonction + elaguer(fils); + + // On libère le plateau: + for(j=0; j<(taillePlateau*taillePlateau); j++) + free((fils->plateau)[j]); + free(fils->plateau); + + // On peut maintenant libérer ce fils + free(noeud->listeFils[i]); + } + // On libère la liste des fils: + free(noeud->listeFils); + + return 0; +} + diff --git a/olono_X11/src/libPlay.h b/olono_X11/src/libPlay.h new file mode 100644 index 0000000..9067a32 --- /dev/null +++ b/olono_X11/src/libPlay.h @@ -0,0 +1,54 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libPlay.h + * Prototypes de libPlay.c + */ + +#ifndef _LIB_PLAY_H +#define _LIB_PLAY_H + +#include "libCases.h" + +char lister(int x, int y, char couleur, struct _CASE *plateau[], int listeCoups[]); +char valide(int x, int y, char couleur, struct _CASE *plateau[]); +char nbCoupsValides(char couleur, CASE *plateau[], int listeValides[]); +void retourne(int x, int y, struct _CASE *plateau[]); +int peutJouer(char couleur, CASE *plateau[]); +int jouerCoup(int x, int y, char couleur, struct _CASE *plateau[]); +int testFinPartie(struct _CASE *plateau[]); +void score(struct _CASE *plateau[], int * points); +struct _CASE ** createPlateau(); +struct _CASE ** copiePlateau(struct _CASE *plateau[]); +void initPlateau(struct _CASE *plateau[]); +int jouerSonTour(char couleur, CASE *plateau[]); +int jouerTourAdverse(char couleur, CASE *plateau[]); +int jouerTourSimple(char couleur, CASE *plateau[]); +NOEUD * initHistorique(CASE *plateau[], char couleur); +NOEUD * majHistorique(CASE *plateau[], char couleur); +void endHistorique(); +char reculerHistorique(CASE * plateau[]); +char sauterHistorique(CASE * plateau[], NOEUD * destination); +char avancerHistorique(CASE * plateau[]); +void ajouteFils(NOEUD * pere, NOEUD * fils); + +#endif + diff --git a/olono_X11/src/main.c b/olono_X11/src/main.c new file mode 100644 index 0000000..4ab7fd2 --- /dev/null +++ b/olono_X11/src/main.c @@ -0,0 +1,333 @@ +/* This file is part of OloNO + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * main.c + * Contient la boucle principale du programme + */ + +#include +#include +#include + +/// Hey, passage en graphique +#include +#include + + +/// On inclu nos librairies personnelles (attention le chemin est par rapport à . +/// pas par rapport à BASEDIR, et ce, malgrès le make général ! ): +#include "libDefine.h" +#include "libGUI.h" +#include "libIA.h" +#include "libPlay.h" +#include "libCases.h" +#include "libDisplay.h" + +/// Certains compilos définissent _WIN32, d'autres __WIN32 +#ifdef _WIN32 +#ifndef __WIN32 +#define __WIN32 +#endif +#endif + +/// INIT 1 : Préférences globales (built-in default) +int couleurDepart = BLANC; /// Couleur de départ par défaut; +int allowIA = 0; /// Faire jouer l'IA; +int couleurIA = NOIR; /// Couleur de l'IA +int affJouable = 0; /// Afficher les positions jouables; +int taillePlateau = 8; /// Taille du plateau par défaut; + +/// Variables globales : +int jeton = BLANC; /// Comme la couleur de départ; +int aPuJouer[] = {1, 1}; /// Indique que les blancs et les noirs peuvent jouer +int points[] = {0, 0}; /// Points obtenus pour les blancs et les noirs + +window *wOlono; /// Les widgets sont accessibles de n'importe où. +struct _CASE **plateau; +arguments args; +NOEUD *tronc; +preferences prefs; + +FILE * fichierPreferences = NULL; + + +// On utilise agrp pour traiter les options, c'est GNU et c'est joli +// Par contre, il faut un peu de définition, d'où le bloc suivant : + +// ############################################################### // +// ### Ici la magnifique structure bordélique de argp : ########## // +// ############################################################### // +//{ + + +/* + OPTIONS. Field 1 in ARGP. + Order of fields: {NAME, KEY, ARG, FLAGS, DOC}. +*/ +static struct argp_option options[] = +{ + {"taille-plateau", 't', "taillePlateau", 0, "Changer la taille de plateau par défaut (9)"}, + {"verbose", 'v', 0, 0, "Activer les commentaires étendus"}, + {"Tore", 'T', 0, 0, "Avoir un plateau Toroïdal (les bords sont connectés)"}, + {0} +}; + +/* + PARSER. Field 2 in ARGP. + Order of parameters: KEY, ARG, STATE. +*/ +static error_t +parse_opt (int key, char *arg, struct argp_state *state) +{ + arguments *args = state->input; + + switch (key) + { + case 't': + args->taillePlateau = (int) arg; + break; + case 'v': + args->verbose = 1; + break; + case 'T': + args->Tore = 1; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +/* + ARGS_DOC. Field 3 in ARGP. + A description of the non-option command-line arguments + that we accept. +*/ +static char args_doc[] = ""; + +/* + DOC. Field 4 in ARGP. + Program documentation. +*/ +static char doc[] = + "OloNO -- A program to play Othello, simply way better \vOloNO is Not an Othello - C project 2008-2009"; + +/* + The ARGP structure itself. +*/ +static struct argp argp = +{ + options, parse_opt, args_doc, doc +}; + +const char *argp_program_version = + "OloNO " VERSION " - édition 42"; + +const char *argp_program_bug_address = + " &| "; + +//} +// ############################################################### // + + + + +///! Lance le programme +/** + * Cette fonction est la boucle principale du programme. + * Elle permet de rassembler toutes les autres fonctions dans un contenu reflétant + * le fonctionnement du programme. Pour comprendre le fonctionnement d'un programme, + * lire le main() devrait suffire. + * Dans notre cas en revanche ce n'est pas tout à fait exact, car gtk implique + * une execution évènementielle, c'est à dire une éxécution basée sur les + * évènements. Le programme ne se lit donc plus du haut vers le bas, mais en + * fonction des évènements liés à des fonctions dites de callback, dans le fichier + * libGUI.c. + */ +int main(int argc, char ** argv) +{ + + // Commençons par charger les préférences, si elles existent. On ouvre le fichier + // en lecture pour charger la structure préférences : + fichierPreferences = fopen(".olonoPrefs", "rb"); + if (fichierPreferences == NULL) + erreur("Pas de fichier de préférences trouvé\n"); + else + { + // On lit 1 élément de donnée de longueur preferences depuis le fichier + // fPreferences pour le stocker dans la variable prefs (de type preferences) + fread(&prefs,sizeof(preferences),1,fichierPreferences); + + /// INIT 2 : Préférences globales (from file) + couleurDepart = prefs.couleurDepart; + allowIA = prefs.allowIA; + couleurIA = prefs.couleurIA; + affJouable = prefs.affJouable; + taillePlateau = prefs.taillePlateau; + + if (args.verbose) + ecrire("Chargement de :\n\t couleurDepart: %d, allowIA : %d\n\t couleurIA : %d, taillePlateau: %d",couleurDepart,allowIA,couleurIA,taillePlateau); + } + + + + /* On initialise les arguments à leur valeur par défaut */ + args.taillePlateau = 0; + args.verbose = 0; + args.Tore = 0; + + /* This is where the magic should happen | Attention, instant magique ... */ + argp_parse (&argp, argc, argv, 0, 0, &args); + + /// INIT 3 : Préférences globales (from) + if (args.taillePlateau != 0) + if (atoi((char*) args.taillePlateau) <= 25 && atoi((char*) args.taillePlateau) >= 4) + taillePlateau = atoi((char*) args.taillePlateau); + + + /// Les 3 priorités d'initialisation étant terminées, on peut désormais + // assigner la couleur de départ du jeton : + jeton = couleurDepart; + + +/// ######################################################################## /// +/// ### On commence les choses sérieuses ici (cad le main) ################# /// +/// ######################################################################## /// + + gint i=0,j=0,n=0; + CASE caseActuelle[625]; + + wOlono = g_malloc(sizeof(window)); + + plateau = createPlateau(); + initPlateau(plateau); + tronc = initHistorique(plateau,couleurDepart); + + +/// ######################################################################## /// +/// ### On fait chauffer l'Interface Graphique ############################# /// +/// ######################################################################## /// + GladeXML *xml; + + /* Initialisation de la lib GTK+ */ + gtk_init(&argc, &argv); + + /* load the interface and complete it with the variable pieces */ + xml = glade_xml_new(DATADIR "/" GLADEDIR "/" GLADEFILE, NULL, NULL); + + /* connect the signals in the interface */ + glade_xml_signal_autoconnect(xml); + + /* // timer up*/ + /* wOlono->pIAClock = g_timer_new();*/ + /* g_timer_start(wOlono->pIAClock);*/ + + // get the main Window + wOlono->pWindow = glade_xml_get_widget(xml, "olonoWindow"); + gtk_window_set_title(GTK_WINDOW (wOlono->pWindow), "OloNO v" VERSION); + + // get checkBoxes, and set their values + wOlono->pCheckAllowIA = glade_xml_get_widget(xml, "allowIA"); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (wOlono->pCheckAllowIA),allowIA); + wOlono->pCheckiaIsBlack = glade_xml_get_widget(xml, "iaIsBlack"); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (wOlono->pCheckiaIsBlack),couleurIA); + wOlono->pCheckAffJouable = glade_xml_get_widget(xml, "showPossibleMoves"); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (wOlono->pCheckAffJouable),affJouable); + wOlono->pCheckCouleurDeb = glade_xml_get_widget(xml, "whiteStart"); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (wOlono->pCheckCouleurDeb),!couleurDepart); + + // also get the spin button and set the default value : + wOlono->pSpinTT = glade_xml_get_widget(xml, "taillePlateau"); + gtk_spin_button_set_value(GTK_SPIN_BUTTON (wOlono->pSpinTT),taillePlateau); + + // why not speak to the prefs window too ? + wOlono->pPrefWindow = glade_xml_get_widget(xml, "olonoPreferences"); + + // get the status bar : + wOlono->pStatusBar = glade_xml_get_widget(xml, "barreDesTaches"); + + // creating context ids : + wOlono->contextId01 = gtk_statusbar_get_context_id(GTK_STATUSBAR(wOlono->pStatusBar), + "MsgTour"); + wOlono->contextId02 = gtk_statusbar_get_context_id(GTK_STATUSBAR(wOlono->pStatusBar), + "MsgScore"); + + // creating first blank message for contextId01 : + gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), + GPOINTER_TO_INT(wOlono->contextId01),"Bienvenue - Youkoso"); + + // On s'occupe de charger les images en mémoire : + wOlono->imgVide = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGVIDE,&wOlono->gerror); + wOlono->imgBlanche = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGBLANCHE,&wOlono->gerror); + wOlono->imgNoire = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGNOIRE,&wOlono->gerror); + wOlono->imgJoker = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGJOKER,&wOlono->gerror); + + // Puis on créé les dérivées transparentes : + wOlono->imgTransBlanche = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGTBLANCHE,&wOlono->gerror); + wOlono->imgTransNoire = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGTNOIRE,&wOlono->gerror); + + + // set the plateau. + wOlono->pPlateau = gtk_table_new(taillePlateau,taillePlateau,TRUE); + + for (i=0;ipImage[n] = gtk_image_new(); + wOlono->pEvent[n] = gtk_event_box_new (); + gtk_container_add (GTK_CONTAINER (wOlono->pEvent[n]), wOlono->pImage[n]); + + // Important : On place le gtk_event_box au dessus sinon on peut pas + // recevoir des évènements, puisqu'il est caché par l'image. + gtk_event_box_set_above_child (GTK_EVENT_BOX (wOlono->pEvent[n]),1); + + // On rempli caseActuelle : + caseActuelle[n].x = i; + caseActuelle[n].y = j; + + // On connecte chaque signal à la fonction callback : + g_signal_connect (G_OBJECT (wOlono->pEvent[n]), + "button_press_event", + G_CALLBACK (on_case_clic), + &caseActuelle[n]); + + gtk_table_attach_defaults (GTK_TABLE (wOlono->pPlateau), + wOlono->pEvent[n], i, i+1, j, j+1); + } + } + + /* Rafraichit le plateau (fait concorder celui en mémoire et celui affiché) */ + refreshBoard(plateau); + + wOlono->pContainer = glade_xml_get_widget(xml, "cadreAspect"); + gtk_container_add(GTK_CONTAINER(wOlono->pContainer), wOlono->pPlateau); + + /* For all the abandonned widgets ie plateau */ + gtk_widget_show_all (wOlono->pPlateau); + + /* start the event loop */ + gtk_main(); + + return 0; +} + diff --git a/olono_console/COPYING b/olono_console/COPYING new file mode 100644 index 0000000..94a9ed0 --- /dev/null +++ b/olono_console/COPYING @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. 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 +them 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 prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. 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. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey 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; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If 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 convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU 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 that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + 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. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +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. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + 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 +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + 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 3 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, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program 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, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU 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 Lesser General +Public License instead of this License. But first, please read +. diff --git a/olono_console/Changelog b/olono_console/Changelog new file mode 100644 index 0000000..f95b4df --- /dev/null +++ b/olono_console/Changelog @@ -0,0 +1,16 @@ +Version 0.1 + Written in Python + Quite working referee + +Version 0.2 + Rewritten in C + Working referee + +Version 0.3 + Can finish a match and name the winner + Implementation des arguments + +Version 0.4 + New algorythm for validation function + Can play on a pseudo-sphere (meaning the borders are connected) + diff --git a/olono_console/Makefile b/olono_console/Makefile new file mode 100644 index 0000000..da0dbf3 --- /dev/null +++ b/olono_console/Makefile @@ -0,0 +1,42 @@ +OPTS = -g -p -Wall #-pedantic + +default: all +all: libs olono + +libs: libIA libDisplay libPlay libCases + +olono:main.o + gcc -o olono main.o ../lib/libCases.so ../lib/libIA.so ../lib/libDisplay.so ../lib/libPlay.so $(OPTS) + +libIA: + gcc -c ../lib/libIA.c -o ../lib/libIA.o $(OPTS) + gcc -o ../lib/libIA.so -shared ../lib/libIA.o $(OPTS) + +libDisplay: + gcc -c ../lib/libDisplay.c -o ../lib/libDisplay.o $(OPTS) + gcc -o ../lib/libDisplay.so -shared ../lib/libDisplay.o $(OPTS) + +libPlay: + gcc -c ../lib/libPlay.c -o ../lib/libPlay.o $(OPTS) + gcc -o ../lib/libPlay.so -shared ../lib/libPlay.o $(OPTS) + +libCases: + gcc -c ../lib/libCases.c -o ../lib/libCases.o $(OPTS) + gcc -o ../lib/libCases.so -shared ../lib/libCases.o $(OPTS) + +main.o: + gcc -c main.c $(OPTS) + +doc: + doxygen ../doxygen/Doxyfile + $(MAKE) -C ../doxygen/latex -f Makefile + +clean: + rm -v *.o + rm -v ./olono + +mrproper: + rm -v *.o + rm -v ./olono + rm -vR ../doxygen/html ../doxygen/latex + diff --git a/olono_console/main.c b/olono_console/main.c new file mode 100644 index 0000000..cf27a34 --- /dev/null +++ b/olono_console/main.c @@ -0,0 +1,264 @@ +/* This file is part of OloNO + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * main.c + * Contient la boucle principale du programme + */ + +#include +#include +#include + +// On inclu nos librairies personnelles : +#include "../lib/libDefine.h" +#include "../lib/libDisplay.h" +#include "../lib/libPlay.h" +#include "../lib/libCases.h" + +void boucleDeJeu(struct _CASE *plateau[]); + +// Certains compilos définissent _WIN32, d'autres __WIN32 +#ifdef _WIN32 +#ifndef __WIN32 +#define __WIN32 +#endif +#endif + +// On utilise agrp pour traiter les options, c'est GNU et c'est joli +// Par contre, il faut un peu de définition, d'où le bloc suivant : + +// ############################################################### // +// ### Ici la magnifique structure bordélique de argp : ########## // +// ############################################################### // +//{ + + +/* + OPTIONS. Field 1 in ARGP. + Order of fields: {NAME, KEY, ARG, FLAGS, DOC}. +*/ +static struct argp_option options[] = +{ + {"taille-plateau", 't', "TAILLE", 0, "Changer la taille de plateau par défaut (9)" + }, + {"verbose", 'v', 0, 0, "Activer les commentaires étendus"}, + {"Tore", 'T', 0, 0, "Avoir un plateau Toroïdal (les bords sont connectés)"}, + {0} +}; + +/* + PARSER. Field 2 in ARGP. + Order of parameters: KEY, ARG, STATE. +*/ +static error_t +parse_opt (int key, char *arg, struct argp_state *state) +{ + arguments *args = state->input; + + switch (key) + { + case 't': + args->taillePlateau = (int)arg; + break; + case 'v': + args->verbose = 1; + break; + case 'T': + args->Tore = 1; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +/* + ARGS_DOC. Field 3 in ARGP. + A description of the non-option command-line arguments + that we accept. +*/ +static char args_doc[] = ""; + +/* + DOC. Field 4 in ARGP. + Program documentation. +*/ +static char doc[] = + "OloNO -- A program to play Othello, simply way better \vOloNO is Not an Othello - C project 2008-2009"; + +/* + The ARGP structure itself. +*/ +static struct argp argp = +{ + options, parse_opt, args_doc, doc +}; +//} +// ############################################################### // + +const char *argp_program_version = + "OloNO 0.4 - édition 42"; + +const char *argp_program_bug_address = + " &| "; + +// Variables globales +arguments args; +int taillePlateau = 9; // Taille du plateau par défaut; + +//! Lance le programme +/** + * Cette fonction est la boucle principale du programme. + * Elle permet de rassembler toutes les autres fonctions dans un contenu reflétant + * le fonctionnement du programme. Pour comprendre le fonctionnement d'un programme, + * lire le main() devrait suffire. +*/ +int main(int argc, char ** argv) +{ + + /* On initialise les arguments à leur valeur par défaut */ + args.taillePlateau = 0; + args.verbose = 0; + args.Tore = 0; + + /* This is where the magic should happen | Attention, instant magique ... */ + argp_parse (&argp, argc, argv, 0, 0, &args); + + // Si l'argument --taille-plateau ou -t est placé alors il override la taille par défaut. + if (args.taillePlateau != 0) + taillePlateau = atoi((char *)args.taillePlateau); + + if (taillePlateau < 4 || taillePlateau > 25) + { + printf("La taile doit être comprise entre 4 et 25"); + return -1; + } + + +// ############################################################### // +// ### On commence les choses sérieuses ici (cad le main) ######## // +// ############################################################### // + + int i=0; // Variables de boucle. + int points[]={0, 0}; // Points obtenus pour les blancs et les noirs + + +// ######################################################################################### // +// # ETAPE 1 : Dire Bonjour (c'est important de saluer son utilisateur, qu'on se le dise). # // +// ######################################################################################### // + + direBonjour(); + + // si l'argument -T ou --Tore est placé alors on le rappelle au joueur + if (args.Tore) + ecrire ("Vous avez choisi le mode Toroïdal :p \n"); + +// ######################################################################################### // +// # ETAPE 2 : Initialiser le plateau ###################################################### // +// ######################################################################################### // + + // On créé un tableau à la taille demandée par le joueur + CASE ** plateau = createPlateau(); + // On initialise ce tableau avec la consigne + initPlateau(plateau); + +// ######################################################################################### // +// # ETAPE 3 : Boucle de jeux principale ################################################### // +// ######################################################################################### // + + initHistorique(plateau, BLANC); + boucleDeJeu(plateau); + endHistorique(); + + +// ######################################################################################### // +// # ETAPE 4 : Score ####################################################################### // +// ######################################################################################### // + + score(plateau, points); + affichePlateau(plateau); + afficherScore(points); + + + // On oublie pas de libérer l'espace mallocé + for (i=0; i + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. 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 +them 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 prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. 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. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey 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; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If 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 convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU 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 that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + 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. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +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. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + 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 +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + 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 3 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, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program 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, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU 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 Lesser General +Public License instead of this License. But first, please read +. diff --git a/stable/Changelog b/stable/Changelog new file mode 100644 index 0000000..0d9f387 --- /dev/null +++ b/stable/Changelog @@ -0,0 +1,12 @@ +Version 0.1 + Written in Python + Quite working referee + +Version 0.2 + Rewritten in C + Working referee + +Version 0.3 + Can finish a match and name the winner + Implementation des arguments + diff --git a/stable/Makefile b/stable/Makefile new file mode 100644 index 0000000..0a6a918 --- /dev/null +++ b/stable/Makefile @@ -0,0 +1,36 @@ +OPTS = -g + +default: olono +all: olono + +olono:libCases.o libPlay.o libDisplay.o main.o + gcc -o olono libCases.o libDisplay.o libPlay.o main.o $(OPTS) + +libInit.o: libInit.c + gcc -o libInit.o -c libInit.c $(OPTS) + +libDisplay.o: libDisplay.c + gcc -o libDisplay.o -c libDisplay.c $(OPTS) + +libPlay.o: libPlay.c + gcc -o libPlay.o -c libPlay.c $(OPTS) + +libCases.o: libCases.c + gcc -o libCases.o -c libCases.c $(OPTS) + +main.o: main.c + gcc -o main.o -c main.c $(OPTS) + +doc: + doxygen ../doxygen/Doxyfile + $(MAKE) -C ../doxygen/latex -f Makefile + +clean: + rm -v *.o + rm -v ./olono + +mrproper: + rm -v *.o + rm -v ./olono + rm -vR ../doxygen/html ../doxygen/latex + diff --git a/stable/libCases.c b/stable/libCases.c new file mode 100644 index 0000000..8e1eaf3 --- /dev/null +++ b/stable/libCases.c @@ -0,0 +1,57 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include +#include "libDefine.h" +#include "libCases.h" + +CASE * adresseParXY(int x, int y, CASE *plateau[], int taillePlateau) +{ + if (x>=taillePlateau || y>=taillePlateau + || x<0 || y<0) + return NULL; + + return plateau[x*taillePlateau + y]; +} + +/** + * Prend une case et un vecteur en argument, ainsi que la taille du plateau et + * la liste des cases. Renvoie l'adresse de la case suivante sur ce vecteur + */ +CASE * caseSuivante(CASE depart, int incX, int incY, CASE *plateau[], int taillePlateau) +{ + int x, y; + + // Si on arrive au bout du plateau (depart.x+incX = taillePlateau), on + // repart à 0. idem pour y + x = depart.x + incX; + if (x == taillePlateau) + x = 0; + else if (x == -1) + x = taillePlateau-1; + + y = depart.y + incY; + if (y == taillePlateau) + y = 0; + else if (y == -1) + y = taillePlateau-1; + + return adresseParXY(x, y, plateau, taillePlateau); +} diff --git a/stable/libCases.h b/stable/libCases.h new file mode 100644 index 0000000..b01ccd7 --- /dev/null +++ b/stable/libCases.h @@ -0,0 +1,35 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// Comme certaines librairies incluent cette lib et des libs qui l'incluent +// aussi, il ne faut le lire qu'une fois +#ifndef _LIB_CASES_H +#define _LIB_CASES_H +//! Structure de case. +typedef struct _CASE +{ + char couleur; /**< Couleur de la case */ + int x, y; +} CASE; + +CASE * adresseParXY(int x, int y, CASE *plateau[], int taillePlateau); +CASE * caseSuivante(CASE depart, int incX, int incY, CASE *plateau[], int taillePlateau); +#endif + diff --git a/stable/libDefine.h b/stable/libDefine.h new file mode 100644 index 0000000..f1a7367 --- /dev/null +++ b/stable/libDefine.h @@ -0,0 +1,32 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libDefine.h + * Contient des macros et des structures pour tout le programme. + * Elles définissent les valeurs d'int associées aux 4 types de cases. De la + * même manière est définit la taille d'un plateau par défaut. + */ + +#define VIDE 3 +#define BLANC 0 +#define NOIR 1 +#define JOKER 2 + diff --git a/stable/libDisplay.c b/stable/libDisplay.c new file mode 100644 index 0000000..3475c7b --- /dev/null +++ b/stable/libDisplay.c @@ -0,0 +1,156 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libDisplay.c (console) + * Contient les fonctions d'affichage en mode console: + * concerne aussi bien l'affichage de la grille que les entrées utilisateur. + */ + +#include +#include +#include +#include +#include "libDefine.h" +#include "libPlay.h" +#include "libDisplay.h" + +//! Demande les coordonnées au joueur +/** + * Cette fonction demande à l'utilisateur les coordonnées du point à jouer + * et les converti pour qu'elles correspondent aux indices en mémoire. +*/ +void demanderXY(int coords[], int taillePlateau) +{ + char x=0; + int y=0; + int retourScanf; + + do + { + printf("Entrez les coordonnées où jouer: "); + scanf(" %c%d%*[^\n]", &x, &y); + + int c; + // ... On vide le flux + while ( ((c = getchar()) != '\n') && c != EOF); + } + while (!( x>=65 && (x-65)=0 && ycouleur]); + } + printf("\n"); // après chaque ligne, retour à la ligne + } + printf(" "); + for (i=0;i 25)) + { + printf("Taille impaire (5-25) : "); + retourScanf = scanf("%d%*[^\n]",&taillePlateau); + // Si le scanf a retourné une erreur ... + if (!retourScanf) + { + // ... On vide le flux + int c; + while ( ((c = getchar()) != '\n') && c != EOF); + } + else + // Si tout s'est bien passé, on enlève le \n final + getchar(); + } + + return taillePlateau; +} + diff --git a/stable/libDisplay.h b/stable/libDisplay.h new file mode 100644 index 0000000..29eeb46 --- /dev/null +++ b/stable/libDisplay.h @@ -0,0 +1,31 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libDisplay.h + * Prototypes de libDisplay.c + */ + +#include "libCases.h" + +void demanderXY(int coords[], int taillePlateau); +void affichePlateau(CASE *plateau[],int taillePlateau); +void ecrire(char *chaine, ...); +int demanderTaillePlateau(); diff --git a/stable/libPlay.c b/stable/libPlay.c new file mode 100644 index 0000000..b7ab100 --- /dev/null +++ b/stable/libPlay.c @@ -0,0 +1,334 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libPlay.c + * Librairie indépendante du mode d'affichage. + * Elle gère toutes les règles du jeu et s'occupe d'effectuer les mouvements + * comme les retournements de pions. + */ + +#include +#include +#include "libPlay.h" +#include "libDefine.h" +#include "libDisplay.h" + +//! Renvoie 0 si le coup n'est pas valide, le nombre de pièces qu'il retourne sinon. +/** + * Cette fonction renvoie le nombre de pièces à retourner et met les + * coordonnées des pièces à retourner dans le pointeur listeCoups. + * + * La liste increments contient les vecteurs selon lesquels parcourir le + * tableau: on suit toutes les droites et diagonales (première boucle for). + * Au début de chaque vecteur, on vérifie qu'on reste dans la plateau, que + * la case immédiatement n'est ni vide ni de la couleur du joueur. Dans le + * cas contraire, on passe immédiatement au vecteur suivant. + * Une fois ces prérequis vérifiés, on parcourt la suite du vecteur à la + * recherche d'une pierre amie (le while(!rencontre)). + * Si on tombe sur une pierre amie, alors on parcourt le vecteur en sans + * inverse (la boucle sur j. Ici gît). Dans cette boucle, la liste des + * coups est mise à jour et le compteur incrémenté (celui qu'on renvoie) + * + * A tout moment, si on rencontre un joker, on le saute, c'est à dire qu'on fait un + * continue. +*/ +char valide(int x,int y,char couleur,CASE *plateau[],int taillePlateau, int listeCoups[]) +{ + CASE caseDepart, caseTemp; + char increments[8][2] = + { + {-1, -1}, + {-1, 0}, + {-1, 1}, + { 0, 1}, + { 1, 1}, + { 1, 0}, + { 1, -1}, + { 0, -1} + }; // Liste des vecteurs + char inc=0; // Parcourt les vecteurs + char i=0, j=0; + char coups=0; // Compteur de nombre de coups + + caseDepart = *adresseParXY(x, y, plateau, taillePlateau); + + if (caseDepart.couleur != VIDE) + return 0; + + // On parcourt les vecteurs + for (inc=0; inc<8; inc++) + { + char incX=increments[inc][0], incY=increments[inc][1]; + char rencontre = 0; // determine si on a rencontre un ami + char couleurCase; + + caseTemp = *caseSuivante(caseDepart, incX, incY, plateau, taillePlateau); + // Si on tombe ensuite sur une case de la meme couleur ou vide, on saute + if ( (caseTemp.couleur == couleur) || (caseTemp.couleur == VIDE) ) + continue; + // Dans les autres cas, on continue d'incrementer + i=1; // i est le compteur d'increments + while (!rencontre) + { + i++; // On passe a la case suivante le long du vecteur + //char X = x + (i*incX); + //char Y = y + (i*incY); + + caseTemp = *caseSuivante(caseTemp, incX, incY, plateau, taillePlateau); + couleurCase = caseTemp.couleur; + + // Si on tombe sur le joker, on passe cette case: + if (couleurCase == JOKER) + { + continue; + } + // Case Vide, Stop: + if (couleurCase == VIDE) + { + break; + } + // Si on tombe sur un ami: + if (couleurCase == couleur) + { + rencontre = 1; + // On met les cases dans la liste et on agmente le compteur + for (j=i-1; j>0; j--) + { + caseTemp = *caseSuivante(caseTemp, -incX, -incY, plateau, taillePlateau); + if (caseTemp.couleur == JOKER) // Le joker, on saute + continue; + listeCoups[coups++] = (caseTemp.x)*taillePlateau + caseTemp.y; + // Pour retrouver la case: x = coup/taille et y = coup%taille + } + break; // On a trouve qqn et on a rentre les coups. On passe au vecteur suivant + } + } + } + + return coups; +} + +//! Retourne un Pion +/** + * Échange, entre NOIR et BLANC, la couleur d'une case. + * Si la case est vide ou un joker, ne fait rien. +*/ +void retourne(int x, int y, CASE *plateau[], int taillePlateau) +{ + CASE * caseARetourner = adresseParXY(x, y, plateau, taillePlateau); + char couleur = caseARetourner->couleur; + + // Le reste est tout con + if (couleur == BLANC) + couleur = NOIR; + // Important tout de même de else if, sinon ça ne marche pas. + else if (couleur == NOIR) + couleur = BLANC; + // Si c JOKER VIDE ou quoi que ce soit d'autre on se casse, c'est pas notre boulot. + else + return; + caseARetourner->couleur = couleur; +} + +//! Détermine si une coordonnée se trouve dans le plateau ou non. +/** + * Cette fonction détermine si une coordonnée se trouve dans le plateau ou non. + * Si oui elle renvoit 1, sinon elle renvoit 0. +*/ +int caseDansLeTableau(int x, int y, int taillePlateau) +{ + return !(x>(taillePlateau-1) || x<0 || y>(taillePlateau-1) || y<0); +} + +//! Joue le tour actuel si possible. +/** + * Cette fonction, appelée par le main, joue le tour d'un joueur passé + * en argument. S'il y a lieu, il retourne les pions et place le pion du + * joueur. + * Elle renvoie ensuite le nombre de pièces retournées. + * Donc si le joueur ne peut pas jouer, la fonction ne fait rien et renvoie 0. + */ +int jouerTour(char couleur, CASE *plateau[], int taillePlateau) +{ + int nbCoups=0; + int coords[2] = {0, 0}; + int * listeCoups = malloc((taillePlateau - 3)*4 * sizeof(int)); + int i, j; + CASE * caseJouee; + + // On cherche s'il existe au moins 1 coup possible + for (i=0; icouleur = couleur; + + free(listeCoups); + return nbCoups; +} + +//! Teste la fin de partie. +/** + * La partie se finit si le plateau est rempli ou si un joueur n'as plus de + * pièces sur le plateau (Là, il l'a mauvaise). Dans ce cas cette fonction renvoi 1. + * Tant que la partie n'est pas finie, cette fonction renvoi 0 + */ +int testFinPartie(CASE *plateau[], int taillePlateau) +{ + int i, j; + int unicolore=1, plein=1; + char couleur[2] = {0, 0}; + + for (i=0; icouleur == BLANC) + { + points[0]++; + } + if (adresseParXY(i, j, plateau, taillePlateau)->couleur == NOIR) + { + points[1]++; + } + } + } +} + +//! Renvoit un simple pointeur comme tableau multidim +/** + * Crée et envoie une liste de pointeurs qui représente le tableau. + * Le pointeur renvoyé représente les colonne et chaque pointeur dans cette + * liste est une ligne. Le tableau renvoyé est initialisé à VIDE. +*/ +CASE ** createPlateau(int taillePlateau) +{ + // On crée une liste de pointeurs sur les cases + CASE ** plateau = malloc(taillePlateau * taillePlateau * sizeof(CASE *)); + // On crée maintenant chaque case, et on met son pointeur dans la liste + int i=0; + for (i=0;i<(taillePlateau*taillePlateau);i++) + { + plateau[i] = malloc(sizeof(CASE)); + plateau[i]->x = i / taillePlateau; + plateau[i]->y = i % taillePlateau; + plateau[i]->couleur = VIDE; + } + + // Cette fonction renvoit un pointeur sur le plateau + // pour modif et affichage ultérieur. + return plateau; +} + +//! Rempli le centre d'un tableau passé en argument +/** + * Initialise la partie en ajoutant au tableau vide le carré central donné + * en consigne. Il contient un Joker en son centre. +*/ +void initPlateau(CASE *plateau[],int taillePlateau) +{ + // Le motif donné par la consigne : + char motif[9] = {BLANC,NOIR,BLANC,BLANC,JOKER,NOIR,NOIR,BLANC,NOIR}; + // La position de début du motif est à : + int debut = (taillePlateau/2)-1; + + int i=0,j=0; + for (i=0;i<3;i++) + { + for (j=0;j<3;j++) + { + adresseParXY(debut+i, debut+j, plateau, taillePlateau)->couleur = motif[j*3+i]; + } + } +} + diff --git a/stable/libPlay.h b/stable/libPlay.h new file mode 100644 index 0000000..ff3bae1 --- /dev/null +++ b/stable/libPlay.h @@ -0,0 +1,36 @@ +/* This file is part of Olono + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * libPlay.h + * Prototypes de libPlay.c + */ + +#include "libCases.h" + +char valide(int x, int y, char couleur, struct _CASE *plateau[], int taillePlateau, int listeCoups[]); +void retourne(int x, int y, struct _CASE *plateau[],int taillePlateau); +int caseDansLeTableau(int x, int y, int taillePlateau); +int jouerTour(char couleur, struct _CASE *plateau[], int taillePlateau); +int testFinPartie(struct _CASE *plateau[], int taillePlateau); +void score(struct _CASE *plateau[], int taillePlateau, int * points); +struct _CASE ** createPlateau(int taillePlateau); +void initPlateau(struct _CASE *plateau[],int taillePlateau); + diff --git a/stable/main.c b/stable/main.c new file mode 100644 index 0000000..5d9caaa --- /dev/null +++ b/stable/main.c @@ -0,0 +1,250 @@ +/* This file is part of OloNO + Copyright (C) 2008 Martin Potier () and + David Wagner () + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; version 3 + of the License. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +/** \file + * main.c + * Contient la boucle principale du programme + */ + +#include +#include +#include + +// On inclu nos librairies personnelles : +#include "libDefine.h" +#include "libDisplay.h" +#include "libPlay.h" +#include "libCases.h" + +// Certains compilos définissent _WIN32, d'autres __WIN32 +#ifdef _WIN32 + #ifndef __WIN32 + #define __WIN32 + #endif +#endif + +// On utilise agrp pour traiter les options, c'est GNU et c'est joli +// Par contre, il faut un peu de définition, d'où le bloc suivant : + +// ############################################################### // +// ### Ici la magnifique structure bordélique de argp : ########## // +// ############################################################### // +//{ + + /* This structure is used by main to communicate with parse_opt. */ + struct arguments + { + int argTaillePlateau; /* Arguments for -t */ + int verbose; /* Arguments for -v */ + }; + + /* + OPTIONS. Field 1 in ARGP. + Order of fields: {NAME, KEY, ARG, FLAGS, DOC}. + */ + static struct argp_option options[] = + { + {"taille-plateau", 't', 0, 0, + "Changer la taille de plateau par défaut (9)" + }, + {"verbose", 'v', 0, 0, "Activer les commentaires étendus"}, + {0} + }; + + /* + PARSER. Field 2 in ARGP. + Order of parameters: KEY, ARG, STATE. + */ + static error_t + parse_opt (int key, char *arg, struct argp_state *state) + { + struct arguments *arguments = state->input; + + switch (key) + { + case 't': + arguments->argTaillePlateau = 1; + break; + case 'v': + arguments->verbose = 1; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; + } + + /* + ARGS_DOC. Field 3 in ARGP. + A description of the non-option command-line arguments + that we accept. + */ + static char args_doc[] = ""; + + /* + DOC. Fielhttp://www.gnu.org/software/libtool/manual/libc/Argp-Example-4.html#Argp-Example-4d 4 in ARGP. + Program documentation. + */ + static char doc[] = + "OloNO -- A program to play Othello, simply way better \vOloNO is Not an Othello - C project 2008-2009"; + + /* + The ARGP structure itself. + */ + static struct argp argp = + { + options, parse_opt, args_doc, doc + }; +//} +// ############################################################### // + +const char *argp_program_version = +"OloNO 0.3 - édition 42"; + +const char *argp_program_bug_address = +" &| "; + +//! Lance le programme +/** + * Cette fonction est la boucle principale du programme. + * Elle permet de rassembler toutes les autres fonctions dans un contenu reflétant + * le fonctionnement du programme. Pour comprendre un programme, lire le main() devrait suffire. +*/ +int main(int argc, char ** argv) +{ +// ############################################################### // +// ### On traite les arguments : init puis affectation ########### // +// ############################################################### // + + struct arguments arguments; + FILE *outstream; + + /* On initialise les arguments à leur valeur par défaut */ + arguments.argTaillePlateau = 0; + arguments.verbose = 0; + + /* This is where the magic should happen | Attention, instant magique ... */ + argp_parse (&argp, argc, argv, 0, 0, &arguments); + + +// ############################################################### // +// ### On commence les choses sérieuses ici (cad le main) ######## // +// ############################################################### // + + int taillePlateau=9; // Taille du plateau par défaut; + int i=0, j=0; // Variables de boucle. + int coords[]={0, 0}; // Coordonnees demandées a chaque tour + char couleur; // Couleur d'une pièce + int points[]={0, 0}; // Points obtenus pour les blancs et les noirs + int peutJouer[]={1, 1}; + + ecrire("\tOloNO Copyright (C) 2008 David Wagner && Martin Potier\n\ +\tThis program comes with ABSOLUTELY NO WARRANTY;\n\ +\tThis is free software, and you are welcome to redistribute it under\n\ +\tcertain conditions\n\n"); + + ecrire("Bienvenue à OloNO\nOloNO is not an othello\n\n"); + + // Si l'argument --taille-plateau ou -t est placé alors il override la taille par défaut. + if (arguments.argTaillePlateau) + taillePlateau = demanderTaillePlateau(); + + // On créé un tableau à la taille demandée par le joueur + CASE ** plateau = createPlateau(taillePlateau); + // On initialise ce tableau avec la consigne + initPlateau(plateau,taillePlateau); + // Affichage, tableau initial : +#if 0 + int listeCoups[81]; + affichePlateau(plateau, taillePlateau); + demanderXY(coords, taillePlateau); + int nbCoups = valide(coords[0],coords[1],BLANC,plateau,taillePlateau,listeCoups); + if (nbCoups)// Pour les tests: d'abord jouer une case valide + { + ecrire("Coup Valide\n"); + if (arguments.verbose == 1) + ecrire("nombre de pièces à retourner: %d\n", nbCoups); + for (i=0; i points[1]) + ecrire("Les blancs gagnent par %d à %d\n", points[0], points[1]); + else if (points[1] > points[0]) + ecrire("Les noirs gagnent par %d à %d\n", points[1], points[0]); + else + ecrire("Partie nulle: %d partout\n", points[0]); +#endif + + // On oublie pas de libérer l'espace mallocé + for (i=0; i