ajout du controleur SDL

ElderInternalIgnition/ElderInternalIgnition.cbp

@@ -32,11 +32,14 @@
 			<Add directory="./../Libs/libroxml-2.3.0/src" />
 			<Add directory="./../src" />
 			<Add directory="./../Libs/SDL-1.2.15/include" />
+			<Add directory="../Libs/cmocka-1.0.0/include" />
 		</Compiler>
 		<Linker>
-			<Add library="..\Libs\libroxml-2.3.0\Build\libroxml.dll" />
-			<Add library=".\..\Libs\SDL-1.2.15\bin\SDL.dll" />
+			<Add library="../Libs/libroxml-2.3.0/Build/libroxml.dll" />
+			<Add library="./../Libs/SDL-1.2.15/bin/SDL.dll" />
+			<Add library="../Libs/cmocka-1.0.0/lib/cmocka.dll.a" />
 			<Add directory="./../Libs" />
+			<Add directory="../Libs/cmocka-1.0.0/lib" />
 		</Linker>
 		<Unit filename="../src/AffichageConsole.c">
 			<Option compilerVar="CC" />

Libs/cmocka-1.0.0/CMake/cmocka/cmocka-config-version.cmake

+set(PACKAGE_VERSION 1.0.0)
+
+# Check whether the requested PACKAGE_FIND_VERSION is compatible
+if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}")
+        set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+endif()

Libs/cmocka-1.0.0/CMake/cmocka/cmocka-config.cmake

+get_filename_component(CMOCKA_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+
+if (EXISTS "${CMOCKA_CMAKE_DIR}/CMakeCache.txt")
+    # In build tree
+    include(${CMOCKA_CMAKE_DIR}/cmocka-build-tree-settings.cmake)
+else()
+    set(CMOCKA_INCLUDE_DIR include)
+endif()
+
+set(CMOCKA_LIBRARY lib/libcmocka.dll)
+set(CMOCKA_LIBRARIES lib/libcmocka.dll)

Libs/cmocka-1.0.0/include/cmocka_pbc.h

+/*
+ * Copyright 2014 Luis Pabon, Jr.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Programming by Contract is a programming methodology
+ * which binds the caller and the function called to a
+ * contract. The contract is represented using Hoare Triple:
+ *      {P} C {Q}
+ * where {P} is the precondition before executing command C,
+ * and {Q} is the postcondition.
+ *
+ * See also:
+ * http://en.wikipedia.org/wiki/Design_by_contract
+ * http://en.wikipedia.org/wiki/Hoare_logic
+ * http://dlang.org/dbc.html
+ */
+#ifndef CMOCKA_PBC_H_
+#define CMOCKA_PBC_H_
+
+#if defined(UNIT_TESTING) || defined (DEBUG)
+
+#include <assert.h>
+
+/*
+ * Checks caller responsibility against contract
+ */
+#define REQUIRE(cond) assert(cond)
+
+/*
+ * Checks function reponsability against contract.
+ */
+#define ENSURE(cond) assert(cond)
+
+/*
+ * While REQUIRE and ENSURE apply to functions, INVARIANT
+ * applies to classes/structs.  It ensures that intances
+ * of the class/struct are consistent. In other words,
+ * that the instance has not been corrupted.
+ */
+#define INVARIANT(invariant_fnc) do{ (invariant_fnc) } while (0);
+
+#else
+#define REQUIRE(cond) do { } while (0);
+#define ENSURE(cond) do { } while (0);
+#define INVARIANT(invariant_fnc) do{ } while (0);
+
+#endif /* defined(UNIT_TESTING) || defined (DEBUG) */
+#endif /* CMOCKA_PBC_H_ */
+

Libs/cmocka-1.0.0/lib/pkgconfig/cmocka.pc

+Name: cmocka
+Description: The cmocka unit testing library
+Version: 1.0.0
+Libs: -Llib -lcmocka
+Cflags: -Iinclude
+

src/competence.c

@@ -8,25 +8,93 @@
 * \brief Fichier contenant le code des fonctions liees aux arbres de compétences.
 */
 
-Arbre_Competence* init_arbre_competence(Arbre_Competence *a){
-    return NULL;
+/*! Copie de la struct Competence pour travailler
+
+typedef struct Competence{
+    char nomComp[TAILLE_NOMS];
+    char id[TAILLE_ID];
+    unsigned int prix_competence;
+    struct Competence *frere;
+    struct Competence *enfant;
+    struct Effet_Competence *effet;
+    boolean connu;
+}Competence;
+
+*/
+
+int taille(Competence *noeud)
+{
+    Competence *enfant;
+    int compteur = 1;
+    for (enfant = noeud->enfant; enfant != NULL; enfant = enfant->frere)
+        compteur += taille(enfant);
+    return compteur;
 }
 
-Arbre_Competence* construire_arbre_competence(Arbre_Competence* a){  /* Construit un arbre à partir d'un fichier XML */
+unsigned int hauteur(Competence *noeud)
+{
+    if (!estVide(noeud))
+    {
+        int compteur = 1;
+        Competence *enfant;
+        for (enfant = noeud->enfant; enfant != NULL; enfant = enfant->frere)
+        {
+            if (hauteur(enfant) > compteur)
+            compteur = 1 + hauteur(enfant);
+        }
+        return compteur;
+    }else{
+        return 0;
+    }
+}
+
+int estVide(Competence *c)
+{
+    if (c->enfant == NULL)
+        return 0;
+    else
+        return 1;
+}
+
+boolean est_connue(Competence *c)
+{
+    return (c->connu);
+}
+
+
+unsigned int NbEnfants(Competence *noeud)
+{
+    unsigned int nb;
+	if (estVide(noeud))
+    {
+        nb = 0;
+    }
+    else
+    {
+        Competence *enfant;
+        for(noeud->enfant; enfant!= NULL; enfant=enfant->frere);
+
+		nb++;
+    }
+    return nb;
+}
+
+
+/* -------------------------------------------------------------------------------------- */
+
+Competence* construire_arbre_competence(Competence* a){
     return NULL;
 
 }
 
-int rafraichir_competences(Arbre_Competence * a){
+int rafraichir_competences(Competence * a){
     return 0;
 }
 
 
-boolean est_connue(Competence *c){
-    return (c->connu);
-}
 
-boolean est_complet(Arbre_Competence *a){
+
+boolean est_complet(Competence *a){
     return 0;
 }
 

src/competence.h

@@ -6,49 +6,22 @@
 #ifndef DEPLACEMENTS_H_INCLUDED
 #define DEPLACEMENTS_H_INCLUDED
 
-/* Definition des structures */
-
-/* A definir dans structure.h */
-typedef struct Arbre_Competence{     /* Arbre de compétence */
-}Arbre_Competence;
-
-
-
-
+/* Fonctions */
 
+int taille(Competence *noeud);
 
-/*  //Cette structure est deja definie dans structure.h
-    typedef struct Competence{      // Competence d'un arbre de talent
-    unsigned short int id;
-    type_nom nom;
-    unsigned short int etage;
-    struct competence *parent;
-    struct competence *enfant_gauche;
-    struct competence *enfant_droit;
-    struct effet_competence *effet;
-    boolean connu;
-}competence;
-*/
+unsigned int NbEnfants(Competence *noeud);
 
-/* //Cette structure est deja definie dans structure.h
-typedef struct effet_competence{        // Effet d'une compétence de l'arbre
-    unsigned short int id;
-    type_nom nom;
-    // effets à définir
-}effet_competence;
-*/
-
-/* Fonctions */
+unsigned int hauteur(Competence *noeud);
 
-Arbre_Competence* init_arbre_competence(Arbre_Competence *a);
 
-Arbre_Competence* construire_arbre_competence(Arbre_Competence* a);
+Competence* construire_arbre_competence(Competence* a);
 
-int rafraichir_competences(Arbre_Competence * a);
+int rafraichir_competences(Competence * a);
 
 boolean est_connue(Competence *c);
 
-boolean est_complet(Arbre_Competence *a);
+boolean est_complet(Competence *a);
 
 Effet_Competence * get_effet(Competence *c);