SimpleOS

LXR

Navigation



Site hébergé par : enix

The LXR Cross Referencer for SOS

source navigation ]
diff markup ]
identifier search ]
general search ]
 
 
Article:1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 6.5 ] [ 7 ] [ 7.5 ] [ 8 ] [ 9 ] [ 9.5 ]

Diff markup

Differences between /sos/mouse_sim.c (Article 9.5) and /sos/mouse_sim.c (Article 8)


001 /*********************************************    001 /***************************************************************************
002  *   Copyright (C) 2004 by cyril dupuit           002  *   Copyright (C) 2004 by cyril dupuit                                    *
003  *   cyrildupuit@hotmail.com                      003  *   cyrildupuit@hotmail.com                                               *
004  *   http://perso.wanadoo.fr/koalys/              004  *   http://perso.wanadoo.fr/koalys/                                       *
005  *   (Adaptation for SOS by d2 -- 2004/12/20)     005  *   (Adaptation for SOS by d2 -- 2004/12/20)                              *
006  *                                                006  *                                                                         *
007  *   This program is free software; you can re    007  *   This program is free software; you can redistribute it and/or modify  *
008  *   it under the terms of the GNU General Pub    008  *   it under the terms of the GNU General Public License as published by  *
009  *   the Free Software Foundation; either vers    009  *   the Free Software Foundation; either version 2 of the License, or     *
010  *   (at your option) any later version.          010  *   (at your option) any later version.                                   *
011  *                                                011  *                                                                         *
012  *   This program is distributed in the hope t    012  *   This program is distributed in the hope that it will be useful,       *
013  *   but WITHOUT ANY WARRANTY; without even th    013  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
014  *   MERCHANTABILITY or FITNESS FOR A PARTICUL    014  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
015  *   GNU General Public License for more detai    015  *   GNU General Public License for more details.                          *
016  *                                                016  *                                                                         *
017  *   You should have received a copy of the GN    017  *   You should have received a copy of the GNU General Public License     *
018  *   along with this program; if not, write to    018  *   along with this program; if not, write to the                         *
019  *   Free Software Foundation, Inc.,              019  *   Free Software Foundation, Inc.,                                       *
020  *   59 Temple Place - Suite 330, Boston, MA      020  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
021  *********************************************    021  ***************************************************************************/
022                                                   022 
023 //********************************************    023 //*****************************************************************************
024 // Nom du module : MouseSim.c                     024 // Nom du module : MouseSim.c
025 // Description : Creation et destruction de so    025 // Description : Creation et destruction de souris mangeuse de fromages
026 //********************************************    026 //*****************************************************************************
027                                                   027 
028 #include <sos/assert.h>                           028 #include <sos/assert.h>
029 #include <sos/klibc.h>                            029 #include <sos/klibc.h>
030 #include <sos/thread.h>                           030 #include <sos/thread.h>
031 #include <sos/ksynch.h>                           031 #include <sos/ksynch.h>
032 #include <sos/kmalloc.h>                          032 #include <sos/kmalloc.h>
033 #include <drivers/x86_videomem.h>                 033 #include <drivers/x86_videomem.h>
034                                                   034  
035 // Historique :                                   035 // Historique :
036 // 20/12/04 : Suppr DestroyMap et suppr handle    036 // 20/12/04 : Suppr DestroyMap et suppr handler kbd dans version LM (d2)
037 // 26/11/04 : Bug trouve et resolu dans la fon    037 // 26/11/04 : Bug trouve et resolu dans la fonction DestroyMap
038 // 21/11/04 : Creation du module V1.0             038 // 21/11/04 : Creation du module V1.0
039                                                   039 
040 //********************************************    040 //*****************************************************************************
041 // Definition des equivalences :                  041 // Definition des equivalences :
042 //********************************************    042 //*****************************************************************************
043 #define MAP_X           76                        043 #define MAP_X           76
044 #define MAP_Y           12                        044 #define MAP_Y           12
045 #define MAP_SIZE        MAP_X * MAP_Y             045 #define MAP_SIZE        MAP_X * MAP_Y
046                                                   046 
047 #define MOUSE   0x01                              047 #define MOUSE   0x01
048 #define CHEESE  0x02                              048 #define CHEESE  0x02
049 #define OBSTACLE 0x04                             049 #define OBSTACLE 0x04
050 #define INPUT   0x08                              050 #define INPUT   0x08
051 #define OUTPUT  0x10                              051 #define OUTPUT  0x10
052                                                   052 
053 #define OBSTACLE_COUNT  100                       053 #define OBSTACLE_COUNT  100
054 #define CHEESE_COUNT    650                       054 #define CHEESE_COUNT    650
055                                                   055 
056 #define MOUSE_FULL      0x01                      056 #define MOUSE_FULL      0x01
057 #define MOUSE_EMPTY     0x02                      057 #define MOUSE_EMPTY     0x02
058 #define CHEESE_FOUND    0x04                      058 #define CHEESE_FOUND    0x04
059 #define MOUSE_EXITED    0x08                      059 #define MOUSE_EXITED    0x08
060                                                   060 
061 #define MOUSE_SPEED_MAX 1000                      061 #define MOUSE_SPEED_MAX 1000
062 #define MOUSE_SPEED_MIN 4                         062 #define MOUSE_SPEED_MIN 4
063                                                   063 
064 typedef unsigned int Color_t;                     064 typedef unsigned int Color_t;
065                                                   065 
066 struct Point{                                     066 struct Point{
067         int X;                                    067         int X;
068         int Y;                                    068         int Y;
069         };                                        069         };
070                                                   070 
071 typedef struct Point Point_t;                     071 typedef struct Point Point_t;
072                                                   072 
073 #define Set(Reg, Flag)          Reg = (Reg | F    073 #define Set(Reg, Flag)          Reg = (Reg | Flag)
074 #define Reset(Reg, Flag)        Reg = (Reg &(~    074 #define Reset(Reg, Flag)        Reg = (Reg &(~Flag))
075 #define IsSet(Reg, Flag)        (Reg & Flag)      075 #define IsSet(Reg, Flag)        (Reg & Flag)
076                                                   076 
077                                                   077 
078 //********************************************    078 //*****************************************************************************
079 // Structure de gestion d'un element              079 // Structure de gestion d'un element
080 //********************************************    080 //*****************************************************************************
081 struct Element{                                   081 struct Element{
082         sos_ui32_t              Type;//Type d'    082         sos_ui32_t              Type;//Type d'element
083         sos_ui32_t              Status;           083         sos_ui32_t              Status;
084         Color_t                 Color;//Couleu    084         Color_t                 Color;//Couleur de l'element
085         Point_t                 P;//Coordonnee    085         Point_t                 P;//Coordonnees de l'element
086         struct sos_thread *     ThreadID;//Thr    086         struct sos_thread *     ThreadID;//Thread associe a la souris
087         int                     Way;//Directio    087         int                     Way;//Direction de la souris
088         };                                        088         };
089                                                   089 
090 typedef struct Element Element_t;                 090 typedef struct Element Element_t;
091                                                   091 
092 //********************************************    092 //*****************************************************************************
093 // Prototypes des fonctions/procedures :          093 // Prototypes des fonctions/procedures :
094 //********************************************    094 //*****************************************************************************
095 static void DrawMap(void);                        095 static void DrawMap(void);
096 static sos_ret_t CreateMap(void);                 096 static sos_ret_t CreateMap(void);
097 static sos_ret_t InitMapInput(Element_t * * pM    097 static sos_ret_t InitMapInput(Element_t * * pMap);
098 static sos_ret_t InitMapOutput(Element_t * * p    098 static sos_ret_t InitMapOutput(Element_t * * pMap);
099 static sos_ret_t ElementInit(Element_t * * pMa    099 static sos_ret_t ElementInit(Element_t * * pMap, unsigned int Type);
100 static void Mouse(unsigned long Param);           100 static void Mouse(unsigned long Param);
101 static void MouseMove(Point_t * P);               101 static void MouseMove(Point_t * P);
102 static Point_t ChoosePosition(Element_t * pMou    102 static Point_t ChoosePosition(Element_t * pMouse, int Positions[], int Count);
103 static int EvaluatePositions(Point_t Org, int     103 static int EvaluatePositions(Point_t Org, int Positions[], Point_t * Cheese);
104 static sos_bool_t IsCollision(Point_t Org, Poi    104 static sos_bool_t IsCollision(Point_t Org, Point_t p, Point_t *Cheese);
105 static sos_bool_t AffectMovement(Point_t Org,     105 static sos_bool_t AffectMovement(Point_t Org, Point_t p);
106 static void MouseCreator(void);                   106 static void MouseCreator(void);
107 static sos_ret_t CreateMouse(void);               107 static sos_ret_t CreateMouse(void);
108                                                   108 
109 //********************************************    109 //*****************************************************************************
110 // Variables globales de ce module :              110 // Variables globales de ce module :
111 //********************************************    111 //*****************************************************************************
112                                                   112 
113 static Element_t * * pMap;                        113 static Element_t * * pMap;
114 static struct sos_ksema SemMap;                   114 static struct sos_ksema SemMap;
115 static struct sos_ksema SemMouse;                 115 static struct sos_ksema SemMouse;
116 static int MouseCount = 0;                        116 static int MouseCount = 0;
117 static int CheeseCount = 0;                       117 static int CheeseCount = 0;
118 static int ObstacleCount = 0;                     118 static int ObstacleCount = 0;
119 static int MouseSpeed = 100;                      119 static int MouseSpeed = 100;
120                                                   120 
121 //********************************************    121 //*****************************************************************************
122 // Koalys Glue                                    122 // Koalys Glue
123 //********************************************    123 //*****************************************************************************
124 void DrawPixel(int x, int y, Color_t color)       124 void DrawPixel(int x, int y, Color_t color)
125 {                                                 125 {
126   sos_x86_videomem_putchar(y+3, x+2, color, 21    126   sos_x86_videomem_putchar(y+3, x+2, color, 219);
127 }                                                 127 }
128                                                   128 
129                                                   129 
130                                                   130 
131 //********************************************    131 //*****************************************************************************
132 // Point d'entre de la 'simulation'               132 // Point d'entre de la 'simulation'
133 //********************************************    133 //*****************************************************************************
134 void MouseSim(void)                               134 void MouseSim(void)
135 {                                                 135 {
136   //Creation du semaphore de protection de la     136   //Creation du semaphore de protection de la carte
137   SOS_ASSERT_FATAL(SOS_OK == sos_ksema_init(&     137   SOS_ASSERT_FATAL(SOS_OK == sos_ksema_init(& SemMap, "SemMap", 1,
138                                             SO    138                                             SOS_KWQ_ORDER_FIFO));
139                                                   139         
140   //Creation du semaphore de creation de souri    140   //Creation du semaphore de creation de souris
141   SOS_ASSERT_FATAL(SOS_OK == sos_ksema_init(&     141   SOS_ASSERT_FATAL(SOS_OK == sos_ksema_init(& SemMouse, "SemMouse", 2,
142                                             SO    142                                             SOS_KWQ_ORDER_FIFO));
143                                                   143         
144   //Creation de la carte                          144   //Creation de la carte
145   SOS_ASSERT_FATAL(SOS_OK == CreateMap());        145   SOS_ASSERT_FATAL(SOS_OK == CreateMap());
146                                                   146 
147   //Creation du thread createur de souris         147   //Creation du thread createur de souris
148   SOS_ASSERT_FATAL(sos_create_kernel_thread("M    148   SOS_ASSERT_FATAL(sos_create_kernel_thread("MouseCreator",
149                                             (s    149                                             (sos_kernel_thread_start_routine_t)MouseCreator,
150                                             0,    150                                             0, SOS_SCHED_PRIO_TS_LOWEST-1) != NULL);
151                                                   151 
152 }                                                 152 }
153                                                   153 
154                                                   154 
155 //********************************************    155 //*****************************************************************************
156 // But de la fonction : Creer et initialiser l    156 // But de la fonction : Creer et initialiser la carte
157 // Entree : Aucune                                157 // Entree : Aucune
158 // Parametre retourne : ERROR si la memoire es    158 // Parametre retourne : ERROR si la memoire est insuffisante, TRUE sinon
159 //********************************************    159 //*****************************************************************************
160 static sos_ret_t CreateMap(void)                  160 static sos_ret_t CreateMap(void)
161 {                                                 161 {
162         pMap = (Element_t * *)sos_kmalloc(MAP_    162         pMap = (Element_t * *)sos_kmalloc(MAP_SIZE * sizeof(Element_t *), 0);
163         if(pMap == NULL) return -SOS_ENOMEM;      163         if(pMap == NULL) return -SOS_ENOMEM;
164                                                   164         
165         //Mettre la carte a 0                     165         //Mettre la carte a 0
166         memset(pMap, 0, MAP_SIZE * sizeof(Elem    166         memset(pMap, 0, MAP_SIZE * sizeof(Element_t *));
167                                                   167         
168         //Initialisation de l'entree de la car    168         //Initialisation de l'entree de la carte
169         if(SOS_OK != InitMapInput(pMap))          169         if(SOS_OK != InitMapInput(pMap))
170         {//Memoire insuffisante                   170         {//Memoire insuffisante
171                 return -SOS_EFATAL;               171                 return -SOS_EFATAL;
172         }                                         172         }
173                                                   173         
174         //Initialisation de la sortie de la ca    174         //Initialisation de la sortie de la carte
175         if(InitMapOutput(pMap) != SOS_OK)         175         if(InitMapOutput(pMap) != SOS_OK)
176         {//Memoire insuffisante                   176         {//Memoire insuffisante
177                 return -SOS_EFATAL;               177                 return -SOS_EFATAL;
178         }                                         178         }
179                                                   179         
180         //Initialisation du fromage               180         //Initialisation du fromage
181         if(ElementInit(pMap, CHEESE) != SOS_OK    181         if(ElementInit(pMap, CHEESE) != SOS_OK)
182         {//Memoire insuffisante                   182         {//Memoire insuffisante
183                 return -SOS_EFATAL;               183                 return -SOS_EFATAL;
184         }                                         184         }
185                                                   185         
186         //Initialisation des obstacles            186         //Initialisation des obstacles
187         if(ElementInit(pMap, OBSTACLE) != SOS_    187         if(ElementInit(pMap, OBSTACLE) != SOS_OK)
188         {//Memoire insuffisante                   188         {//Memoire insuffisante
189                 return -SOS_EFATAL;               189                 return -SOS_EFATAL;
190         }                                         190         }
191                                                   191         
192         DrawMap();//Afficher la carte creee       192         DrawMap();//Afficher la carte creee
193                                                   193         
194         return SOS_OK;                            194         return SOS_OK;
195 }                                                 195 }
196                                                   196 
197 //********************************************    197 //*****************************************************************************
198 // But de la procedure : Dessiner la carte a l    198 // But de la procedure : Dessiner la carte a l'ecran
199 // Entree : Aucune                                199 // Entree : Aucune
200 // Sortie : Aucune                                200 // Sortie : Aucune
201 //********************************************    201 //*****************************************************************************
202 static void DrawMap(void)                         202 static void DrawMap(void)
203 {                                                 203 {
204         unsigned int I;                           204         unsigned int I;
205                                                   205         
206         for(I = 0; I < MAP_SIZE; I++)             206         for(I = 0; I < MAP_SIZE; I++)
207         {                                         207         {
208                 if(pMap[I] != NULL)               208                 if(pMap[I] != NULL)
209                 {                                 209                 {
210                         DrawPixel(I % MAP_X, I    210                         DrawPixel(I % MAP_X, I/MAP_X, pMap[I]->Color);
211                 }                                 211                 }
212                 else DrawPixel(I % MAP_X, I/MA    212                 else DrawPixel(I % MAP_X, I/MAP_X, SOS_X86_VIDEO_FG_BLACK);
213         }                                         213         }
214         sos_x86_videomem_printf(23, 0, SOS_X86    214         sos_x86_videomem_printf(23, 0, SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
215                                 "Souris = %d;     215                                 "Souris = %d; Fromages = %d; Obstacles = %d       ",
216                                 MouseCount, Ch    216                                 MouseCount, CheeseCount, ObstacleCount);
217 }                                                 217 }
218                                                   218 
219 //********************************************    219 //*****************************************************************************
220 // But de la fonction : Initialiser l'entree d    220 // But de la fonction : Initialiser l'entree de la carte
221 // Entree :                                       221 // Entree :
222 //      pMap : Pointeur sur la carte              222 //      pMap : Pointeur sur la carte
223 // Parametre retourne : ERROR si memoire insuf    223 // Parametre retourne : ERROR si memoire insuffisante, TRUE sinon
224 //********************************************    224 //*****************************************************************************
225 static sos_ret_t InitMapInput(Element_t * * pM    225 static sos_ret_t InitMapInput(Element_t * * pMap)
226 {                                                 226 {
227         Element_t * pElement;                     227         Element_t * pElement;
228                                                   228         
229         //Definir le point d'entree               229         //Definir le point d'entree
230         pElement = (Element_t *)sos_kmalloc(si    230         pElement = (Element_t *)sos_kmalloc(sizeof(Element_t), 0);
231         if(pElement == NULL) return -SOS_ENOME    231         if(pElement == NULL) return -SOS_ENOMEM;
232                                                   232         
233         //Initialiser l'entree                    233         //Initialiser l'entree
234         pElement->Type = INPUT;                   234         pElement->Type = INPUT;
235         pElement->Status = 0;                     235         pElement->Status = 0;
236         pElement->Color = SOS_X86_VIDEO_FG_YEL    236         pElement->Color = SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE;
237         pElement->P.X = 0;                        237         pElement->P.X = 0;
238         pElement->P.Y = MAP_Y / 2;                238         pElement->P.Y = MAP_Y / 2;
239         pElement->ThreadID = 0;                   239         pElement->ThreadID = 0;
240                                                   240 
241         pMap[(pElement->P.Y * MAP_X) + pElemen    241         pMap[(pElement->P.Y * MAP_X) + pElement->P.X] = pElement;
242                                                   242 
243         return SOS_OK;                            243         return SOS_OK;
244 }                                                 244 }
245                                                   245 
246 //********************************************    246 //*****************************************************************************
247 // But de la fonction : Initialiser la sortie     247 // But de la fonction : Initialiser la sortie de la carte
248 // Entree :                                       248 // Entree :
249 //      pMap : Pointeur sur la carte              249 //      pMap : Pointeur sur la carte
250 // Parametre retourne : ERROR si memoire insuf    250 // Parametre retourne : ERROR si memoire insuffisante, TRUE sinon
251 //********************************************    251 //*****************************************************************************
252 static sos_ret_t InitMapOutput(Element_t * * p    252 static sos_ret_t InitMapOutput(Element_t * * pMap)
253 {                                                 253 {
254         Element_t * pElement;                     254         Element_t * pElement;
255                                                   255         
256         //Definir le point de sortie              256         //Definir le point de sortie
257         pElement = (Element_t *)sos_kmalloc(si    257         pElement = (Element_t *)sos_kmalloc(sizeof(Element_t), 0);
258         if(pElement == NULL) return -SOS_ENOME    258         if(pElement == NULL) return -SOS_ENOMEM;
259                                                   259         
260         //Initialiser l'entree                    260         //Initialiser l'entree
261         pElement->Type = OUTPUT;                  261         pElement->Type = OUTPUT;
262         pElement->Status = 0;                     262         pElement->Status = 0;
263         pElement->Color = SOS_X86_VIDEO_FG_LTB    263         pElement->Color = SOS_X86_VIDEO_FG_LTBLUE;
264         pElement->P.X = MAP_X - 1;                264         pElement->P.X = MAP_X - 1;
265         pElement->P.Y = MAP_Y / 2;                265         pElement->P.Y = MAP_Y / 2;
266         pElement->ThreadID = 0;                   266         pElement->ThreadID = 0;
267                                                   267 
268         pMap[(pElement->P.Y * MAP_X) + pElemen    268         pMap[(pElement->P.Y * MAP_X) + pElement->P.X] = pElement;
269                                                   269 
270         return SOS_OK;                            270         return SOS_OK;
271 }                                                 271 }
272                                                   272 
273 //********************************************    273 //*****************************************************************************
274 // But de la fonction : Initialiser un type d'    274 // But de la fonction : Initialiser un type d'objet sur la carte
275 // Entree :                                       275 // Entree : 
276 //      pMap : Pointeur sur la carte              276 //      pMap : Pointeur sur la carte
277 //      Type : Type d'objet a initialiser         277 //      Type : Type d'objet a initialiser
278 // Parametre retourne : ERROR si memoire insuf    278 // Parametre retourne : ERROR si memoire insuffisante, TRUE sinon
279 //********************************************    279 //*****************************************************************************
280 static sos_ret_t ElementInit(Element_t * * pMa    280 static sos_ret_t ElementInit(Element_t * * pMap, unsigned int Type)
281 {                                                 281 {
282         unsigned int I, J;                        282         unsigned int I, J;
283         unsigned int Max;                         283         unsigned int Max;
284         Color_t Color;                            284         Color_t Color;
285                                                   285         
286         if(Type == CHEESE)                        286         if(Type == CHEESE)
287         {//Type d'element = fromage               287         {//Type d'element = fromage
288                 Max = CHEESE_COUNT;               288                 Max = CHEESE_COUNT;
289                 Color = SOS_X86_VIDEO_FG_YELLO    289                 Color = SOS_X86_VIDEO_FG_YELLOW;
290         }                                         290         }
291         else if(Type == OBSTACLE)                 291         else if(Type == OBSTACLE)
292         {//Type d'element = Obstacle              292         {//Type d'element = Obstacle
293                 Max = OBSTACLE_COUNT;             293                 Max = OBSTACLE_COUNT;
294                 Color = SOS_X86_VIDEO_FG_GREEN    294                 Color = SOS_X86_VIDEO_FG_GREEN;
295         }                                         295         }
296         else                                      296         else
297         {//Aucune autre type reconnu              297         {//Aucune autre type reconnu
298                 return -SOS_EINVAL;               298                 return -SOS_EINVAL;
299         }                                         299         }
300                                                   300         
301         for(I = 0; I < Max; I++)                  301         for(I = 0; I < Max; I++)
302         {//Tirer les fromages                     302         {//Tirer les fromages
303                 J = random();                     303                 J = random();
304                 J += random();                    304                 J += random();
305                 J %= MAP_SIZE;                    305                 J %= MAP_SIZE;
306                 if(pMap[J] == NULL)               306                 if(pMap[J] == NULL)
307                 {//Si l'emplacement est libre     307                 {//Si l'emplacement est libre
308                         pMap[J] = (Element_t *    308                         pMap[J] = (Element_t *)sos_kmalloc(sizeof(Element_t),
309                                                   309                                                            0);
310                         if(pMap[J] == NULL) re    310                         if(pMap[J] == NULL) return -SOS_ENOMEM;
311                                                   311 
312                         pMap[J]->Type = Type;     312                         pMap[J]->Type = Type;
313                         //Initialiser l'elemen    313                         //Initialiser l'element
314                         if(Type == CHEESE)        314                         if(Type == CHEESE)
315                         {//Type d'element = fr    315                         {//Type d'element = fromage
316                                 CheeseCount++;    316                                 CheeseCount++;
317                         }                         317                         }
318                         else if(Type == OBSTAC    318                         else if(Type == OBSTACLE)
319                         {//Type d'element = Ob    319                         {//Type d'element = Obstacle
320                                 ObstacleCount+    320                                 ObstacleCount++;
321                         }                         321                         }
322                                                   322                         
323                         pMap[J]->Color = Color    323                         pMap[J]->Color = Color;
324                         pMap[J]->Status = 0;      324                         pMap[J]->Status = 0;
325                         pMap[J]->Color = Color    325                         pMap[J]->Color = Color;
326                         pMap[J]->P.X = J % MAP    326                         pMap[J]->P.X = J % MAP_X;
327                         pMap[J]->P.Y = J / MAP    327                         pMap[J]->P.Y = J / MAP_X;
328                         pMap[J]->ThreadID = 0;    328                         pMap[J]->ThreadID = 0;
329                 }                                 329                 }
330         }                                         330         }
331                                                   331         
332         return SOS_OK;                            332         return SOS_OK;
333 }                                                 333 }
334                                                   334 
335                                                   335 
336 //********************************************    336 //*****************************************************************************
337 // But du thread : Deplacer la souris sur la c    337 // But du thread : Deplacer la souris sur la carte selon les regles etablies.
338 // Regles :                                       338 // Regles :
339 // - La souris doit se placer devant l'entree     339 // - La souris doit se placer devant l'entree puis commence a recolter du
340 // fromage.                                       340 // fromage.
341 // - Des que la souris a ramasse un morceau de    341 // - Des que la souris a ramasse un morceau de fromage, elle doit aller en
342 // entree de la carte afin de deposer sa recol    342 // entree de la carte afin de deposer sa recolte.
343 // - Si une souris a prouve sa recolte, une au    343 // - Si une souris a prouve sa recolte, une autre souris est creee.
344 // - Si une souris prend la sortie, elle est e    344 // - Si une souris prend la sortie, elle est eliminee.
345 //********************************************    345 //*****************************************************************************
346 static void Mouse(unsigned long Param)            346 static void Mouse(unsigned long Param)
347 {                                                 347 {
348         Element_t * pMouse = (Element_t *)Para    348         Element_t * pMouse = (Element_t *)Param;
349         Point_t P;                                349         Point_t P;
350                                                   350         
351         SOS_ASSERT_FATAL(pMouse != NULL);         351         SOS_ASSERT_FATAL(pMouse != NULL);
352                                                   352         
353         //Position de depart de la souris         353         //Position de depart de la souris
354         P = pMouse->P;                            354         P = pMouse->P;
355         P = pMouse->P;                            355         P = pMouse->P;
356                                                   356         
357         while(1)                                  357         while(1)
358         {                                         358         {
359           int delay_ms;                           359           int delay_ms;
360           struct sos_time delay;                  360           struct sos_time delay;
361                                                   361 
362           //La souris doit se deplacer            362           //La souris doit se deplacer
363           sos_ksema_down(& SemMap, NULL);         363           sos_ksema_down(& SemMap, NULL);
364                                                   364 
365           MouseMove(&P);                          365           MouseMove(&P);
366                                                   366           
367           sos_ksema_up(& SemMap);                 367           sos_ksema_up(& SemMap);
368                                                   368 
369           // Est-ce que la souris est sortie ?    369           // Est-ce que la souris est sortie ?
370           if (IsSet(pMouse->Status, MOUSE_EXIT    370           if (IsSet(pMouse->Status, MOUSE_EXITED))
371             // Oui => on sort                     371             // Oui => on sort
372             break;                                372             break;
373                                                   373 
374           // Delai entre MOUSE_SPEED_MIN et Mo    374           // Delai entre MOUSE_SPEED_MIN et MouseSpeed - 1
375           delay_ms = MOUSE_SPEED_MIN + (random    375           delay_ms = MOUSE_SPEED_MIN + (random() % MouseSpeed);
376           delay.sec     = delay_ms / 1000;        376           delay.sec     = delay_ms / 1000;
377           delay.nanosec = (delay_ms % 1000) *     377           delay.nanosec = (delay_ms % 1000) * 1000000;
378           sos_thread_sleep(& delay);              378           sos_thread_sleep(& delay);
379         }                                         379         }
380                                                   380 
381         // Libere la structure associee           381         // Libere la structure associee
382         sos_kfree((sos_vaddr_t)pMouse);           382         sos_kfree((sos_vaddr_t)pMouse);
383 }                                                 383 }
384                                                   384 
385 //********************************************    385 //*****************************************************************************
386 // But de la procedure : Deplacer la souris de    386 // But de la procedure : Deplacer la souris de maniere aleatoire sur la carte
387 // Entrees :                                      387 // Entrees :
388 //      P : Position courante de la souris        388 //      P : Position courante de la souris
389 // Sorties :                                      389 // Sorties :
390 //      P : Position suivante de la souris        390 //      P : Position suivante de la souris
391 //********************************************    391 //*****************************************************************************
392 static void MouseMove(Point_t * P)                392 static void MouseMove(Point_t * P)
393 {                                                 393 {
394         Point_t Org;                              394         Point_t Org;
395         Point_t p;                                395         Point_t p;
396         Point_t Cheese;                           396         Point_t Cheese;
397         int Positions[8];                         397         int Positions[8];
398         int Count = 0;                            398         int Count = 0;
399         Element_t * pMouse;                       399         Element_t * pMouse;
400                                                   400 
401         Org = *P;                                 401         Org = *P;
402                                                   402         
403         pMouse = pMap[Org.X + (Org.Y * MAP_X)]    403         pMouse = pMap[Org.X + (Org.Y * MAP_X)];
404                                                   404         
405         Count = EvaluatePositions(Org, Positio    405         Count = EvaluatePositions(Org, Positions, &Cheese);
406                                                   406 
407         if(Count == 0) return;                    407         if(Count == 0) return;
408                                                   408 
409         p = Org;                                  409         p = Org;
410                                                   410 
411         if(IsSet(pMouse->Status, CHEESE_FOUND)    411         if(IsSet(pMouse->Status, CHEESE_FOUND))
412         {//Prendre le fromage                     412         {//Prendre le fromage
413                 Reset(pMouse->Status, CHEESE_F    413                 Reset(pMouse->Status, CHEESE_FOUND);
414                 p = Cheese;                       414                 p = Cheese;
415         }                                         415         }
416         else                                      416         else
417         {//Choisir une position au hasard         417         {//Choisir une position au hasard
418                 p = ChoosePosition(pMouse, Pos    418                 p = ChoosePosition(pMouse, Positions, Count);
419         }                                         419         }
420         if(AffectMovement(Org, p) == FALSE) re    420         if(AffectMovement(Org, p) == FALSE) return;
421         //Deplacer la souris                      421         //Deplacer la souris
422         pMap[Org.X + (Org.Y * MAP_X)] = NULL;     422         pMap[Org.X + (Org.Y * MAP_X)] = NULL;
423         pMap[p.X + (p.Y * MAP_X)] = pMouse;       423         pMap[p.X + (p.Y * MAP_X)] = pMouse;
424         pMouse->P = p;                            424         pMouse->P = p;
425         //Mettre a jour l'affichage               425         //Mettre a jour l'affichage
426         DrawPixel(Org.X, Org.Y, SOS_X86_VIDEO_    426         DrawPixel(Org.X, Org.Y, SOS_X86_VIDEO_FG_BLACK);
427         DrawPixel(p.X, p.Y, pMouse->Color);       427         DrawPixel(p.X, p.Y, pMouse->Color);
428         sos_x86_videomem_printf( 23,0, SOS_X86    428         sos_x86_videomem_printf( 23,0, SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE, "Souris = %d; Fromages = %d; Obstacles = %d      ", MouseCount, CheeseCount, ObstacleCount);
429         //Mettre a jour les coordonnees           429         //Mettre a jour les coordonnees
430         *P = p;                                   430         *P = p;
431 }                                                 431 }
432                                                   432 
433 //********************************************    433 //*****************************************************************************
434 // But de la fonction : Choisir un mouvement      434 // But de la fonction : Choisir un mouvement
435 // Entree :                                       435 // Entree :
436 //      pMouse : Pointeur sur la souris           436 //      pMouse : Pointeur sur la souris
437 //      Positions : Tableau de position possib    437 //      Positions : Tableau de position possible
438 //      Count :Nombre de positions valides        438 //      Count :Nombre de positions valides
439 // Sortie : Aucune                                439 // Sortie : Aucune
440 // Parametre retourne : Position choisie          440 // Parametre retourne : Position choisie
441 //********************************************    441 //*****************************************************************************
442 static Point_t ChoosePosition(Element_t * pMou    442 static Point_t ChoosePosition(Element_t * pMouse, int Positions[], int Count)
443 {                                                 443 {
444         int I, J;                                 444         int I, J;
445         Point_t p;                                445         Point_t p;
446                                                   446         
447         for(J = 0; J < Count; J++)                447         for(J = 0; J < Count; J++)
448         {//Chercher dans le tableau si cette p    448         {//Chercher dans le tableau si cette position est disponible
449                 I = Positions[J];                 449                 I = Positions[J];
450                 if(I == pMouse->Way)              450                 if(I == pMouse->Way)
451                 {//Poursuivre ce sens d'avance    451                 {//Poursuivre ce sens d'avance
452                         p = pMouse->P;            452                         p = pMouse->P;
453                         switch(I)                 453                         switch(I)
454                         {                         454                         {
455                                 case 0:           455                                 case 0:
456                                         p.Y++;    456                                         p.Y++;
457                                         break;    457                                         break;
458                                 case 1:           458                                 case 1:
459                                         p.X++;    459                                         p.X++;
460                                         p.Y++;    460                                         p.Y++;
461                                         break;    461                                         break;
462                                 case 2:           462                                 case 2:
463                                         p.X++;    463                                         p.X++;
464                                         break;    464                                         break;
465                                 case 3:           465                                 case 3:
466                                         p.Y--;    466                                         p.Y--;
467                                         p.X++;    467                                         p.X++;
468                                         break;    468                                         break;
469                                 case 4:           469                                 case 4:
470                                         p.Y--;    470                                         p.Y--;
471                                         break;    471                                         break;
472                                 case 5:           472                                 case 5:
473                                         p.Y--;    473                                         p.Y--;
474                                         p.X--;    474                                         p.X--;
475                                         break;    475                                         break;
476                                 case 6:           476                                 case 6:
477                                         p.X--;    477                                         p.X--;
478                                         break;    478                                         break;
479                                 case 7:           479                                 case 7:
480                                         p.X--;    480                                         p.X--;
481                                         p.Y++;    481                                         p.Y++;
482                                         break;    482                                         break;
483                         }                         483                         }
484                         return p;                 484                         return p;
485                 }                                 485                 }
486         }                                         486         }
487                                                   487         
488         J = random() % Count;                     488         J = random() % Count;
489         I = Positions[J];                         489         I = Positions[J];
490         if(((I + 4) % 8) == pMouse->Way)          490         if(((I + 4) % 8) == pMouse->Way)
491         {//Eviter le sens inverse                 491         {//Eviter le sens inverse
492                 J = (J + 1) % Count;              492                 J = (J + 1) % Count;
493                 I = Positions[J];                 493                 I = Positions[J];
494         }                                         494         }
495                                                   495         
496         p = pMouse->P;                            496         p = pMouse->P;
497         switch(I)                                 497         switch(I)
498         {//Repere le deplacement                  498         {//Repere le deplacement
499                 case 0:                           499                 case 0:
500                         p.Y++;                    500                         p.Y++;
501                         break;                    501                         break;
502                 case 1:                           502                 case 1:
503                         p.X++;                    503                         p.X++;
504                         p.Y++;                    504                         p.Y++;
505                         break;                    505                         break;
506                 case 2:                           506                 case 2:
507                         p.X++;                    507                         p.X++;
508                         break;                    508                         break;
509                 case 3:                           509                 case 3:
510                         p.Y--;                    510                         p.Y--;
511                         p.X++;                    511                         p.X++;
512                         break;                    512                         break;
513                 case 4:                           513                 case 4:
514                         p.Y--;                    514                         p.Y--;
515                         break;                    515                         break;
516                 case 5:                           516                 case 5:
517                         p.Y--;                    517                         p.Y--;
518                         p.X--;                    518                         p.X--;
519                         break;                    519                         break;
520                 case 6:                           520                 case 6:
521                         p.X--;                    521                         p.X--;
522                         break;                    522                         break;
523                 case 7:                           523                 case 7:
524                         p.X--;                    524                         p.X--;
525                         p.Y++;                    525                         p.Y++;
526                         break;                    526                         break;
527         }                                         527         }
528                                                   528         
529         pMouse->Way = I;//Memoriser la directi    529         pMouse->Way = I;//Memoriser la direction selectionnee
530                                                   530         
531         return p;                                 531         return p;
532 }                                                 532 }
533                                                   533 
534 //********************************************    534 //*****************************************************************************
535 // But de la fonction : Evaluer les positions     535 // But de la fonction : Evaluer les positions possibles et les memoriser dans
536 // un tableau de positions si aucun fromage n'    536 // un tableau de positions si aucun fromage n'a ete detecte. Si du fromage a
537 // ete detecte, il sera selectionne en premier    537 // ete detecte, il sera selectionne en premier. La presence d'un fromage est
538 // indiquee par le drapeau CHEESE_FOUND           538 // indiquee par le drapeau CHEESE_FOUND
539 // Entree :                                       539 // Entree :
540 //      Org : Position de la souris               540 //      Org : Position de la souris
541 // Sorties :                                      541 // Sorties :
542 //      Positions : Tableau de positions valid    542 //      Positions : Tableau de positions valides
543 //      Cheese : Position du fromage              543 //      Cheese : Position du fromage
544 // Parametre retourne : Nombre de positions va    544 // Parametre retourne : Nombre de positions valides
545 //********************************************    545 //*****************************************************************************
546 static int EvaluatePositions(Point_t Org, int     546 static int EvaluatePositions(Point_t Org, int Positions[], Point_t * Cheese)
547 {                                                 547 {
548         int I;                                    548         int I;
549         int Count = 0;                            549         int Count = 0;
550         Point_t p;                                550         Point_t p;
551         Point_t CheesePos;                        551         Point_t CheesePos;
552                                                   552         
553         for(I = 0; I < 8; I++)                    553         for(I = 0; I < 8; I++)
554         {//Explorer toute les directions          554         {//Explorer toute les directions
555                 p = Org;                          555                 p = Org;
556                 switch(I)                         556                 switch(I)
557                 {//Repere le deplacement          557                 {//Repere le deplacement
558                         case 0:                   558                         case 0:
559                                 p.Y++;            559                                 p.Y++;
560                                 break;            560                                 break;
561                         case 1:                   561                         case 1:
562                                 p.X++;            562                                 p.X++;
563                                 p.Y++;            563                                 p.Y++;
564                                 break;            564                                 break;
565                         case 2:                   565                         case 2:
566                                 p.X++;            566                                 p.X++;
567                                 break;            567                                 break;
568                         case 3:                   568                         case 3:
569                                 p.Y--;            569                                 p.Y--;
570                                 p.X++;            570                                 p.X++;
571                                 break;            571                                 break;
572                         case 4:                   572                         case 4:
573                                 p.Y--;            573                                 p.Y--;
574                                 break;            574                                 break;
575                         case 5:                   575                         case 5:
576                                 p.Y--;            576                                 p.Y--;
577                                 p.X--;            577                                 p.X--;
578                                 break;            578                                 break;
579                         case 6:                   579                         case 6:
580                                 p.X--;            580                                 p.X--;
581                                 break;            581                                 break;
582                         case 7:                   582                         case 7:
583                                 p.X--;            583                                 p.X--;
584                                 p.Y++;            584                                 p.Y++;
585                                 break;            585                                 break;
586                 }                                 586                 }
587                 //Tester la collision             587                 //Tester la collision
588                 if(IsCollision(Org, p, &Cheese    588                 if(IsCollision(Org, p, &CheesePos) == FALSE)
589                 {//La souris n'a rencontre auc    589                 {//La souris n'a rencontre aucun obstacle
590                         Positions[Count] = I;     590                         Positions[Count] = I;
591                         Count++;                  591                         Count++;
592                 }                                 592                 }
593         }                                         593         }
594                                                   594         
595         *Cheese = CheesePos;                      595         *Cheese = CheesePos;
596                                                   596 
597         return Count;                             597         return Count;
598 }                                                 598 }
599                                                   599 
600 //********************************************    600 //*****************************************************************************
601 // But de la fonction : Affecter un mouvement     601 // But de la fonction : Affecter un mouvement a la souris
602 // Entrees :                                      602 // Entrees :
603 //      Org : Coordonnees de la souris            603 //      Org : Coordonnees de la souris
604 //      p : Coordonnees voulu par la souris       604 //      p : Coordonnees voulu par la souris
605 // Parametre retourne : TRUE si le mouvement a    605 // Parametre retourne : TRUE si le mouvement a eu lieu, FALSE sinon
606 //********************************************    606 //*****************************************************************************
607 static sos_bool_t AffectMovement(Point_t Org,     607 static sos_bool_t AffectMovement(Point_t Org, Point_t p)
608 {                                                 608 {
609         Element_t * pMouse = pMap[Org.X + (Org    609         Element_t * pMouse = pMap[Org.X + (Org.Y * MAP_X)];
610         Element_t * pElement;                     610         Element_t * pElement;
611                                                   611         
612         pElement = pMap[p.X + (p.Y * MAP_X)];     612         pElement = pMap[p.X + (p.Y * MAP_X)];
613                                                   613         
614         //La place est libre                      614         //La place est libre
615         if(pElement == NULL) return TRUE;//Aut    615         if(pElement == NULL) return TRUE;//Autoriser le mouvement
616                                                   616 
617         switch(pElement->Type)                    617         switch(pElement->Type)
618         {                                         618         {
619                 case CHEESE:                      619                 case CHEESE:
620                         // Liberer l'emplaceme    620                         // Liberer l'emplacement memoire du fromage
621                         sos_kfree((sos_vaddr_t    621                         sos_kfree((sos_vaddr_t)pElement);
622                         pMap[p.X + (p.Y * MAP_    622                         pMap[p.X + (p.Y * MAP_X)] = NULL;
623                                                   623                         
624                         //Donner le fromage a     624                         //Donner le fromage a la souris
625                         Set(pMouse->Status, MO    625                         Set(pMouse->Status, MOUSE_FULL);
626                         Reset(pMouse->Status,     626                         Reset(pMouse->Status, MOUSE_EMPTY);
627                         pMouse->Color = SOS_X8    627                         pMouse->Color = SOS_X86_VIDEO_FG_MAGENTA;
628                         CheeseCount--;            628                         CheeseCount--;
629                         return TRUE;              629                         return TRUE;
630                 case OUTPUT:                      630                 case OUTPUT:
631                         //Supprimer la souris     631                         //Supprimer la souris
632                         pMap[Org.X + (Org.Y *     632                         pMap[Org.X + (Org.Y * MAP_X)] = NULL;
633                         MouseCount--;             633                         MouseCount--;
634                         DrawPixel(Org.X, Org.Y    634                         DrawPixel(Org.X, Org.Y, SOS_X86_VIDEO_FG_BLACK);
635                         sos_x86_videomem_print    635                         sos_x86_videomem_printf( 23,0, SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
636                                                   636                                                  "Souris = %d; Fromages = %d; Obstacles = %d       ",
637                                                   637                                                  MouseCount, CheeseCount,
638                                                   638                                                  ObstacleCount);
639                         Set(pMouse->Status, MO    639                         Set(pMouse->Status, MOUSE_EXITED);
640                         return FALSE;             640                         return FALSE;
641                 default :                         641                 default :
642                         return FALSE;             642                         return FALSE;
643         }                                         643         }
644                                                   644         
645         return FALSE;                             645         return FALSE;
646 }                                                 646 }
647                                                   647 
648 //********************************************    648 //*****************************************************************************
649 // But de la fonction : Tester si une collisio    649 // But de la fonction : Tester si une collision a eu lieu avec un obstacle
650 // Entrees :                                      650 // Entrees :
651 //      Org : Coordonnees de la souris            651 //      Org : Coordonnees de la souris
652 //      p : coordonnees desirees par la souris    652 //      p : coordonnees desirees par la souris
653 // Sortie :                                       653 // Sortie :
654 //      Cheese : Coordonnees du fromage           654 //      Cheese : Coordonnees du fromage
655 // Parametre retourne : TRUE si une collision     655 // Parametre retourne : TRUE si une collision a eu lieu, FALSE sinon
656 //********************************************    656 //*****************************************************************************
657 static sos_bool_t IsCollision(Point_t Org, Poi    657 static sos_bool_t IsCollision(Point_t Org, Point_t p, Point_t *Cheese)
658 {                                                 658 {
659         Element_t * pMouse = pMap[Org.X + (Org    659         Element_t * pMouse = pMap[Org.X + (Org.Y * MAP_X)];
660         Element_t * pElement;                     660         Element_t * pElement;
661                                                   661         
662         //Tester les bordures de la map           662         //Tester les bordures de la map
663         if((p.X < 0)||(p.Y < 0)) return TRUE;     663         if((p.X < 0)||(p.Y < 0)) return TRUE;
664                                                   664         
665         if((p.Y >= MAP_Y)||(p.X >= MAP_X)) ret    665         if((p.Y >= MAP_Y)||(p.X >= MAP_X)) return TRUE;
666                                                   666         
667         pElement = pMap[p.X + (p.Y * MAP_X)];     667         pElement = pMap[p.X + (p.Y * MAP_X)];
668                                                   668         
669         //L'element est vide                      669         //L'element est vide
670         if(pElement == NULL) return FALSE;        670         if(pElement == NULL) return FALSE;
671                                                   671 
672         //Si du fromage a ete trouve, stopper     672         //Si du fromage a ete trouve, stopper la recherche
673         if(IsSet(pMouse->Status, CHEESE_FOUND)    673         if(IsSet(pMouse->Status, CHEESE_FOUND)) return FALSE;
674                                                   674         
675         switch(pElement->Type)                    675         switch(pElement->Type)
676         {                                         676         {
677                 case CHEESE:                      677                 case CHEESE:
678                         if(IsSet(pMouse->Statu    678                         if(IsSet(pMouse->Status, MOUSE_FULL)) return TRUE;
679                         //Indiquer que du from    679                         //Indiquer que du fromage a ete trouve
680                         Set(pMouse->Status, CH    680                         Set(pMouse->Status, CHEESE_FOUND);
681                         //Retenir la position     681                         //Retenir la position du fromage
682                         (*Cheese).X = p.X;        682                         (*Cheese).X = p.X;
683                         (*Cheese).Y = p.Y;        683                         (*Cheese).Y = p.Y;
684                         break;                    684                         break;
685                 case INPUT:                       685                 case INPUT:
686                         if(IsSet(pMouse->Statu    686                         if(IsSet(pMouse->Status, MOUSE_EMPTY)) return TRUE;
687                         //Remplir les reserves    687                         //Remplir les reserves de fromage
688                         Set(pMouse->Status, MO    688                         Set(pMouse->Status, MOUSE_EMPTY);
689                         Reset(pMouse->Status,     689                         Reset(pMouse->Status, MOUSE_FULL);
690                         pMouse->Color = SOS_X8    690                         pMouse->Color = SOS_X86_VIDEO_FG_LTRED;
691                         //Autoriser la creatio    691                         //Autoriser la creation d'une autre souris
692                         sos_ksema_up(& SemMous    692                         sos_ksema_up(& SemMouse);
693                         return TRUE;              693                         return TRUE;
694                 case OUTPUT:                      694                 case OUTPUT:
695                         break;                    695                         break;
696                 default :                         696                 default :
697                         return TRUE;              697                         return TRUE;
698         }                                         698         }
699                                                   699         
700         return FALSE;//Aucune collision           700         return FALSE;//Aucune collision
701 }                                                 701 }
702                                                   702 
703 //********************************************    703 //*****************************************************************************
704 // But du thread : Creer une souris et la plac    704 // But du thread : Creer une souris et la placer autour de l'entree
705 //********************************************    705 //*****************************************************************************
706 static void MouseCreator(void)                    706 static void MouseCreator(void)
707 {                                                 707 {       
708         while(1)                                  708         while(1)
709         {                                         709         {
710                 sos_ksema_down(& SemMouse, NUL    710                 sos_ksema_down(& SemMouse, NULL);
711                 sos_ksema_down(& SemMap, NULL)    711                 sos_ksema_down(& SemMap, NULL);
712                 CreateMouse();                    712                 CreateMouse();
713                 sos_ksema_up(& SemMap);           713                 sos_ksema_up(& SemMap);
714         }                                         714         }
715 }                                                 715 }
716                                                   716 
717 //********************************************    717 //*****************************************************************************
718 // But de la fonction : Creer une souris et l'    718 // But de la fonction : Creer une souris et l'inserer dans la carte
719 // Entree : Aucune                                719 // Entree : Aucune
720 // Parametre retourne : ERROR si memoire insuf    720 // Parametre retourne : ERROR si memoire insuffisante, FALSE si souris non
721 // cree, TRUE sinon                               721 // cree, TRUE sinon
722 //********************************************    722 //*****************************************************************************
723 static sos_ret_t CreateMouse(void)                723 static sos_ret_t CreateMouse(void)
724 {                                                 724 {
725         Element_t * pElement;                     725         Element_t * pElement;
726         unsigned int I;                           726         unsigned int I;
727                                                   727 
728         Point_t p;                                728         Point_t p;
729                                                   729 
730         for(I = 0; I < 8; I++)                    730         for(I = 0; I < 8; I++)
731         {//Explorer tous les emplacements         731         {//Explorer tous les emplacements
732                 p.X = 0;                          732                 p.X = 0;
733                 p.Y = MAP_Y / 2;                  733                 p.Y = MAP_Y / 2;
734                 switch(I)                         734                 switch(I)
735                 {//Repere le deplacement          735                 {//Repere le deplacement
736                         case 0:                   736                         case 0:
737                                 p.Y++;            737                                 p.Y++;
738                                 break;            738                                 break;
739                         case 1:                   739                         case 1:
740                                 p.X++;            740                                 p.X++;
741                                 p.Y++;            741                                 p.Y++;
742                                 break;            742                                 break;
743                         case 2:                   743                         case 2:
744                                 p.X++;            744                                 p.X++;
745                                 break;            745                                 break;
746                         case 3:                   746                         case 3:
747                                 p.Y--;            747                                 p.Y--;
748                                 p.X++;            748                                 p.X++;
749                                 break;            749                                 break;
750                         case 4:                   750                         case 4:
751                                 p.Y--;            751                                 p.Y--;
752                                 break;            752                                 break;
753                         case 5:                   753                         case 5:
754                                 p.Y--;            754                                 p.Y--;
755                                 p.X--;            755                                 p.X--;
756                                 break;            756                                 break;
757                         case 6:                   757                         case 6:
758                                 p.X--;            758                                 p.X--;
759                                 break;            759                                 break;
760                         case 7:                   760                         case 7:
761                                 p.X--;            761                                 p.X--;
762                                 p.Y++;            762                                 p.Y++;
763                                 break;            763                                 break;
764                 }                                 764                 }
765                 if((p.X >= 0)&&(p.Y >= 0)&&(p.    765                 if((p.X >= 0)&&(p.Y >= 0)&&(p.X < MAP_X)&&(p.Y < MAP_Y))
766                 {//L'emplacement est valide       766                 {//L'emplacement est valide
767                         pElement = pMap[p.X +     767                         pElement = pMap[p.X + (p.Y * MAP_X)];
768                         if(pElement == NULL)      768                         if(pElement == NULL)
769                         {//Creer la souris        769                         {//Creer la souris
770                                 pElement = (El    770                                 pElement = (Element_t *)sos_kmalloc(sizeof(Element_t), 0);
771                                 if(pElement !=    771                                 if(pElement != NULL)
772                                 {//Initialiser    772                                 {//Initialiser l'entree
773                                         pEleme    773                                         pElement->Type = MOUSE;
774                                         Set(pE    774                                         Set(pElement->Status, MOUSE_EMPTY);
775                                         pEleme    775                                         pElement->Color = SOS_X86_VIDEO_FG_LTRED;
776                                         pEleme    776                                         pElement->P = p;
777                                         pEleme    777                                         pElement->Way = 0;
778                                         pEleme    778                                         pElement->ThreadID
779                                           = so    779                                           = sos_create_kernel_thread("Mouse",
780                                                   780                                                                      (sos_kernel_thread_start_routine_t)Mouse,
781                                                   781                                                                      pElement, SOS_SCHED_PRIO_TS_LOWEST-1);
782                                         if(pEl    782                                         if(pElement->ThreadID == 0)
783                                         {         783                                         {
784                                                   784                                                 sos_kfree((sos_vaddr_t)pElement);
785                                                   785                                                 pElement = NULL;
786                                                   786                                                 return -SOS_ENOMEM;
787                                         }         787                                         }
788                                         pMap[p    788                                         pMap[p.X + (p.Y * MAP_X)] = pElement;
789                                         MouseC    789                                         MouseCount++;
790                                                   790 
791                                         DrawPi    791                                         DrawPixel(p.X, p.Y, pElement->Color);
792                                         sos_x8    792                                         sos_x86_videomem_printf(23, 0, SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE, "Souris = %d; Fromages = %d; Obstacles = %d       ", MouseCount, CheeseCount, ObstacleCount);
793                                                   793 
794                                         return    794                                         return SOS_OK;
795                                 }                 795                                 }
796                         }                         796                         }
797                 }                                 797                 }
798         }                                         798         }
799         return -SOS_EBUSY;                        799         return -SOS_EBUSY;
800 }                                                 800 }
801                                                   801 
802 //********************************************    802 //*****************************************************************************
803 // C'est fini !!!!                                803 // C'est fini !!!!
804 //********************************************    804 //*****************************************************************************
805                                                   805 

source navigation ] diff markup ] identifier search ] general search ]