Navigation
- Accueil
- Présentation :
- FAQ
- Bugs et errata
- Contributions de lecteurs
- Téléchargements
- LXR (référencement des sources)
- Mailing-list
- Liens et Projets reliés
Site hébergé par :
Site hébergé par :
|
[ source navigation ] [ diff markup ] [ identifier search ] [ general search ] |
|||
|
||||
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 MouseCommander(void); 095 static void DrawMap(void); 096 static void DrawMap(void); 096 static sos_ret_t CreateMap(void); 097 static sos_ret_t CreateMap(void); 097 static sos_ret_t InitMapInput(Element_t * * pM 098 static sos_ret_t InitMapInput(Element_t * * pMap); 098 static sos_ret_t InitMapOutput(Element_t * * p 099 static sos_ret_t InitMapOutput(Element_t * * pMap); 099 static sos_ret_t ElementInit(Element_t * * pMa 100 static sos_ret_t ElementInit(Element_t * * pMap, unsigned int Type); 100 static void Mouse(unsigned long Param); 101 static void Mouse(unsigned long Param); 101 static void MouseMove(Point_t * P); 102 static void MouseMove(Point_t * P); 102 static Point_t ChoosePosition(Element_t * pMou 103 static Point_t ChoosePosition(Element_t * pMouse, int Positions[], int Count); 103 static int EvaluatePositions(Point_t Org, int 104 static int EvaluatePositions(Point_t Org, int Positions[], Point_t * Cheese); 104 static sos_bool_t IsCollision(Point_t Org, Poi 105 static sos_bool_t IsCollision(Point_t Org, Point_t p, Point_t *Cheese); 105 static sos_bool_t AffectMovement(Point_t Org, 106 static sos_bool_t AffectMovement(Point_t Org, Point_t p); 106 static void MouseCreator(void); 107 static void MouseCreator(void); 107 static sos_ret_t CreateMouse(void); 108 static sos_ret_t CreateMouse(void); 108 109 109 //******************************************** 110 //***************************************************************************** 110 // Variables globales de ce module : 111 // Variables globales de ce module : 111 //******************************************** 112 //***************************************************************************** 112 113 113 static Element_t * * pMap; 114 static Element_t * * pMap; 114 static struct sos_ksema SemMap; 115 static struct sos_ksema SemMap; 115 static struct sos_ksema SemMouse; 116 static struct sos_ksema SemMouse; 116 static int MouseCount = 0; 117 static int MouseCount = 0; 117 static int CheeseCount = 0; 118 static int CheeseCount = 0; 118 static int ObstacleCount = 0; 119 static int ObstacleCount = 0; 119 static int MouseSpeed = 100; 120 static int MouseSpeed = 100; 120 121 121 //******************************************** 122 //***************************************************************************** 122 // Koalys Glue 123 // Koalys Glue 123 //******************************************** 124 //***************************************************************************** 124 void DrawPixel(int x, int y, Color_t color) 125 void DrawPixel(int x, int y, Color_t color) 125 { 126 { 126 sos_x86_videomem_putchar(y+3, x+2, color, 21 127 sos_x86_videomem_putchar(y+3, x+2, color, 219); 127 } 128 } 128 129 129 130 130 131 131 //******************************************** 132 //***************************************************************************** 132 // Point d'entre de la 'simulation' 133 // Point d'entre de la 'simulation' 133 //******************************************** 134 //***************************************************************************** 134 void MouseSim(void) 135 void MouseSim(void) 135 { 136 { 136 //Creation du semaphore de protection de la 137 //Creation du semaphore de protection de la carte 137 SOS_ASSERT_FATAL(SOS_OK == sos_ksema_init(& !! 138 SOS_ASSERT_FATAL(SOS_OK == sos_ksema_init(& SemMap, "SemMap", 1)); 138 SO << 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 << 143 142 144 //Creation de la carte 143 //Creation de la carte 145 SOS_ASSERT_FATAL(SOS_OK == CreateMap()); 144 SOS_ASSERT_FATAL(SOS_OK == CreateMap()); 146 145 147 //Creation du thread createur de souris 146 //Creation du thread createur de souris 148 SOS_ASSERT_FATAL(sos_create_kernel_thread("M 147 SOS_ASSERT_FATAL(sos_create_kernel_thread("MouseCreator", 149 (s 148 (sos_kernel_thread_start_routine_t)MouseCreator, 150 0, !! 149 0) != NULL); 151 150 152 } 151 } 153 152 154 153 155 //******************************************** 154 //***************************************************************************** 156 // But de la fonction : Creer et initialiser l 155 // But de la fonction : Creer et initialiser la carte 157 // Entree : Aucune 156 // Entree : Aucune 158 // Parametre retourne : ERROR si la memoire es 157 // Parametre retourne : ERROR si la memoire est insuffisante, TRUE sinon 159 //******************************************** 158 //***************************************************************************** 160 static sos_ret_t CreateMap(void) 159 static sos_ret_t CreateMap(void) 161 { 160 { 162 pMap = (Element_t * *)sos_kmalloc(MAP_ 161 pMap = (Element_t * *)sos_kmalloc(MAP_SIZE * sizeof(Element_t *), 0); 163 if(pMap == NULL) return -SOS_ENOMEM; 162 if(pMap == NULL) return -SOS_ENOMEM; 164 163 165 //Mettre la carte a 0 164 //Mettre la carte a 0 166 memset(pMap, 0, MAP_SIZE * sizeof(Elem 165 memset(pMap, 0, MAP_SIZE * sizeof(Element_t *)); 167 166 168 //Initialisation de l'entree de la car 167 //Initialisation de l'entree de la carte 169 if(SOS_OK != InitMapInput(pMap)) 168 if(SOS_OK != InitMapInput(pMap)) 170 {//Memoire insuffisante 169 {//Memoire insuffisante 171 return -SOS_EFATAL; 170 return -SOS_EFATAL; 172 } 171 } 173 172 174 //Initialisation de la sortie de la ca 173 //Initialisation de la sortie de la carte 175 if(InitMapOutput(pMap) != SOS_OK) 174 if(InitMapOutput(pMap) != SOS_OK) 176 {//Memoire insuffisante 175 {//Memoire insuffisante 177 return -SOS_EFATAL; 176 return -SOS_EFATAL; 178 } 177 } 179 178 180 //Initialisation du fromage 179 //Initialisation du fromage 181 if(ElementInit(pMap, CHEESE) != SOS_OK 180 if(ElementInit(pMap, CHEESE) != SOS_OK) 182 {//Memoire insuffisante 181 {//Memoire insuffisante 183 return -SOS_EFATAL; 182 return -SOS_EFATAL; 184 } 183 } 185 184 186 //Initialisation des obstacles 185 //Initialisation des obstacles 187 if(ElementInit(pMap, OBSTACLE) != SOS_ 186 if(ElementInit(pMap, OBSTACLE) != SOS_OK) 188 {//Memoire insuffisante 187 {//Memoire insuffisante 189 return -SOS_EFATAL; 188 return -SOS_EFATAL; 190 } 189 } 191 190 192 DrawMap();//Afficher la carte creee 191 DrawMap();//Afficher la carte creee 193 192 194 return SOS_OK; 193 return SOS_OK; 195 } 194 } 196 195 197 //******************************************** 196 //***************************************************************************** 198 // But de la procedure : Dessiner la carte a l 197 // But de la procedure : Dessiner la carte a l'ecran 199 // Entree : Aucune 198 // Entree : Aucune 200 // Sortie : Aucune 199 // Sortie : Aucune 201 //******************************************** 200 //***************************************************************************** 202 static void DrawMap(void) 201 static void DrawMap(void) 203 { 202 { 204 unsigned int I; 203 unsigned int I; 205 204 206 for(I = 0; I < MAP_SIZE; I++) 205 for(I = 0; I < MAP_SIZE; I++) 207 { 206 { 208 if(pMap[I] != NULL) 207 if(pMap[I] != NULL) 209 { 208 { 210 DrawPixel(I % MAP_X, I 209 DrawPixel(I % MAP_X, I/MAP_X, pMap[I]->Color); 211 } 210 } 212 else DrawPixel(I % MAP_X, I/MA 211 else DrawPixel(I % MAP_X, I/MAP_X, SOS_X86_VIDEO_FG_BLACK); 213 } 212 } 214 sos_x86_videomem_printf(23, 0, SOS_X86 213 sos_x86_videomem_printf(23, 0, SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE, 215 "Souris = %d; 214 "Souris = %d; Fromages = %d; Obstacles = %d ", 216 MouseCount, Ch 215 MouseCount, CheeseCount, ObstacleCount); 217 } 216 } 218 217 219 //******************************************** 218 //***************************************************************************** 220 // But de la fonction : Initialiser l'entree d 219 // But de la fonction : Initialiser l'entree de la carte 221 // Entree : 220 // Entree : 222 // pMap : Pointeur sur la carte 221 // pMap : Pointeur sur la carte 223 // Parametre retourne : ERROR si memoire insuf 222 // Parametre retourne : ERROR si memoire insuffisante, TRUE sinon 224 //******************************************** 223 //***************************************************************************** 225 static sos_ret_t InitMapInput(Element_t * * pM 224 static sos_ret_t InitMapInput(Element_t * * pMap) 226 { 225 { 227 Element_t * pElement; 226 Element_t * pElement; 228 227 229 //Definir le point d'entree 228 //Definir le point d'entree 230 pElement = (Element_t *)sos_kmalloc(si 229 pElement = (Element_t *)sos_kmalloc(sizeof(Element_t), 0); 231 if(pElement == NULL) return -SOS_ENOME 230 if(pElement == NULL) return -SOS_ENOMEM; 232 231 233 //Initialiser l'entree 232 //Initialiser l'entree 234 pElement->Type = INPUT; 233 pElement->Type = INPUT; 235 pElement->Status = 0; 234 pElement->Status = 0; 236 pElement->Color = SOS_X86_VIDEO_FG_YEL 235 pElement->Color = SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE; 237 pElement->P.X = 0; 236 pElement->P.X = 0; 238 pElement->P.Y = MAP_Y / 2; 237 pElement->P.Y = MAP_Y / 2; 239 pElement->ThreadID = 0; 238 pElement->ThreadID = 0; 240 239 241 pMap[(pElement->P.Y * MAP_X) + pElemen 240 pMap[(pElement->P.Y * MAP_X) + pElement->P.X] = pElement; 242 241 243 return SOS_OK; 242 return SOS_OK; 244 } 243 } 245 244 246 //******************************************** 245 //***************************************************************************** 247 // But de la fonction : Initialiser la sortie 246 // But de la fonction : Initialiser la sortie de la carte 248 // Entree : 247 // Entree : 249 // pMap : Pointeur sur la carte 248 // pMap : Pointeur sur la carte 250 // Parametre retourne : ERROR si memoire insuf 249 // Parametre retourne : ERROR si memoire insuffisante, TRUE sinon 251 //******************************************** 250 //***************************************************************************** 252 static sos_ret_t InitMapOutput(Element_t * * p 251 static sos_ret_t InitMapOutput(Element_t * * pMap) 253 { 252 { 254 Element_t * pElement; 253 Element_t * pElement; 255 254 256 //Definir le point de sortie 255 //Definir le point de sortie 257 pElement = (Element_t *)sos_kmalloc(si 256 pElement = (Element_t *)sos_kmalloc(sizeof(Element_t), 0); 258 if(pElement == NULL) return -SOS_ENOME 257 if(pElement == NULL) return -SOS_ENOMEM; 259 258 260 //Initialiser l'entree 259 //Initialiser l'entree 261 pElement->Type = OUTPUT; 260 pElement->Type = OUTPUT; 262 pElement->Status = 0; 261 pElement->Status = 0; 263 pElement->Color = SOS_X86_VIDEO_FG_LTB 262 pElement->Color = SOS_X86_VIDEO_FG_LTBLUE; 264 pElement->P.X = MAP_X - 1; 263 pElement->P.X = MAP_X - 1; 265 pElement->P.Y = MAP_Y / 2; 264 pElement->P.Y = MAP_Y / 2; 266 pElement->ThreadID = 0; 265 pElement->ThreadID = 0; 267 266 268 pMap[(pElement->P.Y * MAP_X) + pElemen 267 pMap[(pElement->P.Y * MAP_X) + pElement->P.X] = pElement; 269 268 270 return SOS_OK; 269 return SOS_OK; 271 } 270 } 272 271 273 //******************************************** 272 //***************************************************************************** 274 // But de la fonction : Initialiser un type d' 273 // But de la fonction : Initialiser un type d'objet sur la carte 275 // Entree : 274 // Entree : 276 // pMap : Pointeur sur la carte 275 // pMap : Pointeur sur la carte 277 // Type : Type d'objet a initialiser 276 // Type : Type d'objet a initialiser 278 // Parametre retourne : ERROR si memoire insuf 277 // Parametre retourne : ERROR si memoire insuffisante, TRUE sinon 279 //******************************************** 278 //***************************************************************************** 280 static sos_ret_t ElementInit(Element_t * * pMa 279 static sos_ret_t ElementInit(Element_t * * pMap, unsigned int Type) 281 { 280 { 282 unsigned int I, J; 281 unsigned int I, J; 283 unsigned int Max; 282 unsigned int Max; 284 Color_t Color; 283 Color_t Color; 285 284 286 if(Type == CHEESE) 285 if(Type == CHEESE) 287 {//Type d'element = fromage 286 {//Type d'element = fromage 288 Max = CHEESE_COUNT; 287 Max = CHEESE_COUNT; 289 Color = SOS_X86_VIDEO_FG_YELLO 288 Color = SOS_X86_VIDEO_FG_YELLOW; 290 } 289 } 291 else if(Type == OBSTACLE) 290 else if(Type == OBSTACLE) 292 {//Type d'element = Obstacle 291 {//Type d'element = Obstacle 293 Max = OBSTACLE_COUNT; 292 Max = OBSTACLE_COUNT; 294 Color = SOS_X86_VIDEO_FG_GREEN 293 Color = SOS_X86_VIDEO_FG_GREEN; 295 } 294 } 296 else 295 else 297 {//Aucune autre type reconnu 296 {//Aucune autre type reconnu 298 return -SOS_EINVAL; 297 return -SOS_EINVAL; 299 } 298 } 300 299 301 for(I = 0; I < Max; I++) 300 for(I = 0; I < Max; I++) 302 {//Tirer les fromages 301 {//Tirer les fromages 303 J = random(); 302 J = random(); 304 J += random(); 303 J += random(); 305 J %= MAP_SIZE; 304 J %= MAP_SIZE; 306 if(pMap[J] == NULL) 305 if(pMap[J] == NULL) 307 {//Si l'emplacement est libre 306 {//Si l'emplacement est libre 308 pMap[J] = (Element_t * 307 pMap[J] = (Element_t *)sos_kmalloc(sizeof(Element_t), 309 308 0); 310 if(pMap[J] == NULL) re 309 if(pMap[J] == NULL) return -SOS_ENOMEM; 311 310 312 pMap[J]->Type = Type; 311 pMap[J]->Type = Type; 313 //Initialiser l'elemen 312 //Initialiser l'element 314 if(Type == CHEESE) 313 if(Type == CHEESE) 315 {//Type d'element = fr 314 {//Type d'element = fromage 316 CheeseCount++; 315 CheeseCount++; 317 } 316 } 318 else if(Type == OBSTAC 317 else if(Type == OBSTACLE) 319 {//Type d'element = Ob 318 {//Type d'element = Obstacle 320 ObstacleCount+ 319 ObstacleCount++; 321 } 320 } 322 321 323 pMap[J]->Color = Color 322 pMap[J]->Color = Color; 324 pMap[J]->Status = 0; 323 pMap[J]->Status = 0; 325 pMap[J]->Color = Color 324 pMap[J]->Color = Color; 326 pMap[J]->P.X = J % MAP 325 pMap[J]->P.X = J % MAP_X; 327 pMap[J]->P.Y = J / MAP 326 pMap[J]->P.Y = J / MAP_X; 328 pMap[J]->ThreadID = 0; 327 pMap[J]->ThreadID = 0; 329 } 328 } 330 } 329 } 331 330 332 return SOS_OK; 331 return SOS_OK; 333 } 332 } 334 333 335 334 336 //******************************************** 335 //***************************************************************************** 337 // But du thread : Deplacer la souris sur la c 336 // But du thread : Deplacer la souris sur la carte selon les regles etablies. 338 // Regles : 337 // Regles : 339 // - La souris doit se placer devant l'entree 338 // - La souris doit se placer devant l'entree puis commence a recolter du 340 // fromage. 339 // fromage. 341 // - Des que la souris a ramasse un morceau de 340 // - Des que la souris a ramasse un morceau de fromage, elle doit aller en 342 // entree de la carte afin de deposer sa recol 341 // entree de la carte afin de deposer sa recolte. 343 // - Si une souris a prouve sa recolte, une au 342 // - Si une souris a prouve sa recolte, une autre souris est creee. 344 // - Si une souris prend la sortie, elle est e 343 // - Si une souris prend la sortie, elle est eliminee. 345 //******************************************** 344 //***************************************************************************** 346 static void Mouse(unsigned long Param) 345 static void Mouse(unsigned long Param) 347 { 346 { 348 Element_t * pMouse = (Element_t *)Para 347 Element_t * pMouse = (Element_t *)Param; 349 Point_t P; 348 Point_t P; 350 349 351 SOS_ASSERT_FATAL(pMouse != NULL); 350 SOS_ASSERT_FATAL(pMouse != NULL); 352 351 353 //Position de depart de la souris 352 //Position de depart de la souris 354 P = pMouse->P; 353 P = pMouse->P; 355 P = pMouse->P; 354 P = pMouse->P; 356 355 357 while(1) 356 while(1) 358 { 357 { 359 int delay_ms; 358 int delay_ms; 360 struct sos_time delay; 359 struct sos_time delay; 361 360 362 //La souris doit se deplacer 361 //La souris doit se deplacer 363 sos_ksema_down(& SemMap, NULL); 362 sos_ksema_down(& SemMap, NULL); 364 363 365 MouseMove(&P); 364 MouseMove(&P); 366 365 367 sos_ksema_up(& SemMap); 366 sos_ksema_up(& SemMap); 368 367 369 // Est-ce que la souris est sortie ? 368 // Est-ce que la souris est sortie ? 370 if (IsSet(pMouse->Status, MOUSE_EXIT 369 if (IsSet(pMouse->Status, MOUSE_EXITED)) 371 // Oui => on sort 370 // Oui => on sort 372 break; 371 break; 373 372 374 // Delai entre MOUSE_SPEED_MIN et Mo 373 // Delai entre MOUSE_SPEED_MIN et MouseSpeed - 1 375 delay_ms = MOUSE_SPEED_MIN + (random 374 delay_ms = MOUSE_SPEED_MIN + (random() % MouseSpeed); 376 delay.sec = delay_ms / 1000; 375 delay.sec = delay_ms / 1000; 377 delay.nanosec = (delay_ms % 1000) * 376 delay.nanosec = (delay_ms % 1000) * 1000000; 378 sos_thread_sleep(& delay); 377 sos_thread_sleep(& delay); 379 } 378 } 380 379 381 // Libere la structure associee 380 // Libere la structure associee 382 sos_kfree((sos_vaddr_t)pMouse); 381 sos_kfree((sos_vaddr_t)pMouse); 383 } 382 } 384 383 385 //******************************************** 384 //***************************************************************************** 386 // But de la procedure : Deplacer la souris de 385 // But de la procedure : Deplacer la souris de maniere aleatoire sur la carte 387 // Entrees : 386 // Entrees : 388 // P : Position courante de la souris 387 // P : Position courante de la souris 389 // Sorties : 388 // Sorties : 390 // P : Position suivante de la souris 389 // P : Position suivante de la souris 391 //******************************************** 390 //***************************************************************************** 392 static void MouseMove(Point_t * P) 391 static void MouseMove(Point_t * P) 393 { 392 { 394 Point_t Org; 393 Point_t Org; 395 Point_t p; 394 Point_t p; 396 Point_t Cheese; 395 Point_t Cheese; 397 int Positions[8]; 396 int Positions[8]; 398 int Count = 0; 397 int Count = 0; 399 Element_t * pMouse; 398 Element_t * pMouse; 400 399 401 Org = *P; 400 Org = *P; 402 401 403 pMouse = pMap[Org.X + (Org.Y * MAP_X)] 402 pMouse = pMap[Org.X + (Org.Y * MAP_X)]; 404 403 405 Count = EvaluatePositions(Org, Positio 404 Count = EvaluatePositions(Org, Positions, &Cheese); 406 405 407 if(Count == 0) return; 406 if(Count == 0) return; 408 407 409 p = Org; 408 p = Org; 410 409 411 if(IsSet(pMouse->Status, CHEESE_FOUND) 410 if(IsSet(pMouse->Status, CHEESE_FOUND)) 412 {//Prendre le fromage 411 {//Prendre le fromage 413 Reset(pMouse->Status, CHEESE_F 412 Reset(pMouse->Status, CHEESE_FOUND); 414 p = Cheese; 413 p = Cheese; 415 } 414 } 416 else 415 else 417 {//Choisir une position au hasard 416 {//Choisir une position au hasard 418 p = ChoosePosition(pMouse, Pos 417 p = ChoosePosition(pMouse, Positions, Count); 419 } 418 } 420 if(AffectMovement(Org, p) == FALSE) re 419 if(AffectMovement(Org, p) == FALSE) return; 421 //Deplacer la souris 420 //Deplacer la souris 422 pMap[Org.X + (Org.Y * MAP_X)] = NULL; 421 pMap[Org.X + (Org.Y * MAP_X)] = NULL; 423 pMap[p.X + (p.Y * MAP_X)] = pMouse; 422 pMap[p.X + (p.Y * MAP_X)] = pMouse; 424 pMouse->P = p; 423 pMouse->P = p; 425 //Mettre a jour l'affichage 424 //Mettre a jour l'affichage 426 DrawPixel(Org.X, Org.Y, SOS_X86_VIDEO_ 425 DrawPixel(Org.X, Org.Y, SOS_X86_VIDEO_FG_BLACK); 427 DrawPixel(p.X, p.Y, pMouse->Color); 426 DrawPixel(p.X, p.Y, pMouse->Color); 428 sos_x86_videomem_printf( 23,0, SOS_X86 427 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 428 //Mettre a jour les coordonnees 430 *P = p; 429 *P = p; 431 } 430 } 432 431 433 //******************************************** 432 //***************************************************************************** 434 // But de la fonction : Choisir un mouvement 433 // But de la fonction : Choisir un mouvement 435 // Entree : 434 // Entree : 436 // pMouse : Pointeur sur la souris 435 // pMouse : Pointeur sur la souris 437 // Positions : Tableau de position possib 436 // Positions : Tableau de position possible 438 // Count :Nombre de positions valides 437 // Count :Nombre de positions valides 439 // Sortie : Aucune 438 // Sortie : Aucune 440 // Parametre retourne : Position choisie 439 // Parametre retourne : Position choisie 441 //******************************************** 440 //***************************************************************************** 442 static Point_t ChoosePosition(Element_t * pMou 441 static Point_t ChoosePosition(Element_t * pMouse, int Positions[], int Count) 443 { 442 { 444 int I, J; 443 int I, J; 445 Point_t p; 444 Point_t p; 446 445 447 for(J = 0; J < Count; J++) 446 for(J = 0; J < Count; J++) 448 {//Chercher dans le tableau si cette p 447 {//Chercher dans le tableau si cette position est disponible 449 I = Positions[J]; 448 I = Positions[J]; 450 if(I == pMouse->Way) 449 if(I == pMouse->Way) 451 {//Poursuivre ce sens d'avance 450 {//Poursuivre ce sens d'avance 452 p = pMouse->P; 451 p = pMouse->P; 453 switch(I) 452 switch(I) 454 { 453 { 455 case 0: 454 case 0: 456 p.Y++; 455 p.Y++; 457 break; 456 break; 458 case 1: 457 case 1: 459 p.X++; 458 p.X++; 460 p.Y++; 459 p.Y++; 461 break; 460 break; 462 case 2: 461 case 2: 463 p.X++; 462 p.X++; 464 break; 463 break; 465 case 3: 464 case 3: 466 p.Y--; 465 p.Y--; 467 p.X++; 466 p.X++; 468 break; 467 break; 469 case 4: 468 case 4: 470 p.Y--; 469 p.Y--; 471 break; 470 break; 472 case 5: 471 case 5: 473 p.Y--; 472 p.Y--; 474 p.X--; 473 p.X--; 475 break; 474 break; 476 case 6: 475 case 6: 477 p.X--; 476 p.X--; 478 break; 477 break; 479 case 7: 478 case 7: 480 p.X--; 479 p.X--; 481 p.Y++; 480 p.Y++; 482 break; 481 break; 483 } 482 } 484 return p; 483 return p; 485 } 484 } 486 } 485 } 487 486 488 J = random() % Count; 487 J = random() % Count; 489 I = Positions[J]; 488 I = Positions[J]; 490 if(((I + 4) % 8) == pMouse->Way) 489 if(((I + 4) % 8) == pMouse->Way) 491 {//Eviter le sens inverse 490 {//Eviter le sens inverse 492 J = (J + 1) % Count; 491 J = (J + 1) % Count; 493 I = Positions[J]; 492 I = Positions[J]; 494 } 493 } 495 494 496 p = pMouse->P; 495 p = pMouse->P; 497 switch(I) 496 switch(I) 498 {//Repere le deplacement 497 {//Repere le deplacement 499 case 0: 498 case 0: 500 p.Y++; 499 p.Y++; 501 break; 500 break; 502 case 1: 501 case 1: 503 p.X++; 502 p.X++; 504 p.Y++; 503 p.Y++; 505 break; 504 break; 506 case 2: 505 case 2: 507 p.X++; 506 p.X++; 508 break; 507 break; 509 case 3: 508 case 3: 510 p.Y--; 509 p.Y--; 511 p.X++; 510 p.X++; 512 break; 511 break; 513 case 4: 512 case 4: 514 p.Y--; 513 p.Y--; 515 break; 514 break; 516 case 5: 515 case 5: 517 p.Y--; 516 p.Y--; 518 p.X--; 517 p.X--; 519 break; 518 break; 520 case 6: 519 case 6: 521 p.X--; 520 p.X--; 522 break; 521 break; 523 case 7: 522 case 7: 524 p.X--; 523 p.X--; 525 p.Y++; 524 p.Y++; 526 break; 525 break; 527 } 526 } 528 527 529 pMouse->Way = I;//Memoriser la directi 528 pMouse->Way = I;//Memoriser la direction selectionnee 530 529 531 return p; 530 return p; 532 } 531 } 533 532 534 //******************************************** 533 //***************************************************************************** 535 // But de la fonction : Evaluer les positions 534 // But de la fonction : Evaluer les positions possibles et les memoriser dans 536 // un tableau de positions si aucun fromage n' 535 // un tableau de positions si aucun fromage n'a ete detecte. Si du fromage a 537 // ete detecte, il sera selectionne en premier 536 // ete detecte, il sera selectionne en premier. La presence d'un fromage est 538 // indiquee par le drapeau CHEESE_FOUND 537 // indiquee par le drapeau CHEESE_FOUND 539 // Entree : 538 // Entree : 540 // Org : Position de la souris 539 // Org : Position de la souris 541 // Sorties : 540 // Sorties : 542 // Positions : Tableau de positions valid 541 // Positions : Tableau de positions valides 543 // Cheese : Position du fromage 542 // Cheese : Position du fromage 544 // Parametre retourne : Nombre de positions va 543 // Parametre retourne : Nombre de positions valides 545 //******************************************** 544 //***************************************************************************** 546 static int EvaluatePositions(Point_t Org, int 545 static int EvaluatePositions(Point_t Org, int Positions[], Point_t * Cheese) 547 { 546 { 548 int I; 547 int I; 549 int Count = 0; 548 int Count = 0; 550 Point_t p; 549 Point_t p; 551 Point_t CheesePos; 550 Point_t CheesePos; 552 551 553 for(I = 0; I < 8; I++) 552 for(I = 0; I < 8; I++) 554 {//Explorer toute les directions 553 {//Explorer toute les directions 555 p = Org; 554 p = Org; 556 switch(I) 555 switch(I) 557 {//Repere le deplacement 556 {//Repere le deplacement 558 case 0: 557 case 0: 559 p.Y++; 558 p.Y++; 560 break; 559 break; 561 case 1: 560 case 1: 562 p.X++; 561 p.X++; 563 p.Y++; 562 p.Y++; 564 break; 563 break; 565 case 2: 564 case 2: 566 p.X++; 565 p.X++; 567 break; 566 break; 568 case 3: 567 case 3: 569 p.Y--; 568 p.Y--; 570 p.X++; 569 p.X++; 571 break; 570 break; 572 case 4: 571 case 4: 573 p.Y--; 572 p.Y--; 574 break; 573 break; 575 case 5: 574 case 5: 576 p.Y--; 575 p.Y--; 577 p.X--; 576 p.X--; 578 break; 577 break; 579 case 6: 578 case 6: 580 p.X--; 579 p.X--; 581 break; 580 break; 582 case 7: 581 case 7: 583 p.X--; 582 p.X--; 584 p.Y++; 583 p.Y++; 585 break; 584 break; 586 } 585 } 587 //Tester la collision 586 //Tester la collision 588 if(IsCollision(Org, p, &Cheese 587 if(IsCollision(Org, p, &CheesePos) == FALSE) 589 {//La souris n'a rencontre auc 588 {//La souris n'a rencontre aucun obstacle 590 Positions[Count] = I; 589 Positions[Count] = I; 591 Count++; 590 Count++; 592 } 591 } 593 } 592 } 594 593 595 *Cheese = CheesePos; 594 *Cheese = CheesePos; 596 595 597 return Count; 596 return Count; 598 } 597 } 599 598 600 //******************************************** 599 //***************************************************************************** 601 // But de la fonction : Affecter un mouvement 600 // But de la fonction : Affecter un mouvement a la souris 602 // Entrees : 601 // Entrees : 603 // Org : Coordonnees de la souris 602 // Org : Coordonnees de la souris 604 // p : Coordonnees voulu par la souris 603 // p : Coordonnees voulu par la souris 605 // Parametre retourne : TRUE si le mouvement a 604 // Parametre retourne : TRUE si le mouvement a eu lieu, FALSE sinon 606 //******************************************** 605 //***************************************************************************** 607 static sos_bool_t AffectMovement(Point_t Org, 606 static sos_bool_t AffectMovement(Point_t Org, Point_t p) 608 { 607 { 609 Element_t * pMouse = pMap[Org.X + (Org 608 Element_t * pMouse = pMap[Org.X + (Org.Y * MAP_X)]; 610 Element_t * pElement; 609 Element_t * pElement; 611 610 612 pElement = pMap[p.X + (p.Y * MAP_X)]; 611 pElement = pMap[p.X + (p.Y * MAP_X)]; 613 612 614 //La place est libre 613 //La place est libre 615 if(pElement == NULL) return TRUE;//Aut 614 if(pElement == NULL) return TRUE;//Autoriser le mouvement 616 615 617 switch(pElement->Type) 616 switch(pElement->Type) 618 { 617 { 619 case CHEESE: 618 case CHEESE: 620 // Liberer l'emplaceme 619 // Liberer l'emplacement memoire du fromage 621 sos_kfree((sos_vaddr_t 620 sos_kfree((sos_vaddr_t)pElement); 622 pMap[p.X + (p.Y * MAP_ 621 pMap[p.X + (p.Y * MAP_X)] = NULL; 623 622 624 //Donner le fromage a 623 //Donner le fromage a la souris 625 Set(pMouse->Status, MO 624 Set(pMouse->Status, MOUSE_FULL); 626 Reset(pMouse->Status, 625 Reset(pMouse->Status, MOUSE_EMPTY); 627 pMouse->Color = SOS_X8 626 pMouse->Color = SOS_X86_VIDEO_FG_MAGENTA; 628 CheeseCount--; 627 CheeseCount--; 629 return TRUE; 628 return TRUE; 630 case OUTPUT: 629 case OUTPUT: 631 //Supprimer la souris 630 //Supprimer la souris 632 pMap[Org.X + (Org.Y * 631 pMap[Org.X + (Org.Y * MAP_X)] = NULL; 633 MouseCount--; 632 MouseCount--; 634 DrawPixel(Org.X, Org.Y 633 DrawPixel(Org.X, Org.Y, SOS_X86_VIDEO_FG_BLACK); 635 sos_x86_videomem_print 634 sos_x86_videomem_printf( 23,0, SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE, 636 635 "Souris = %d; Fromages = %d; Obstacles = %d ", 637 636 MouseCount, CheeseCount, 638 637 ObstacleCount); 639 Set(pMouse->Status, MO 638 Set(pMouse->Status, MOUSE_EXITED); 640 return FALSE; 639 return FALSE; 641 default : 640 default : 642 return FALSE; 641 return FALSE; 643 } 642 } 644 643 645 return FALSE; 644 return FALSE; 646 } 645 } 647 646 648 //******************************************** 647 //***************************************************************************** 649 // But de la fonction : Tester si une collisio 648 // But de la fonction : Tester si une collision a eu lieu avec un obstacle 650 // Entrees : 649 // Entrees : 651 // Org : Coordonnees de la souris 650 // Org : Coordonnees de la souris 652 // p : coordonnees desirees par la souris 651 // p : coordonnees desirees par la souris 653 // Sortie : 652 // Sortie : 654 // Cheese : Coordonnees du fromage 653 // Cheese : Coordonnees du fromage 655 // Parametre retourne : TRUE si une collision 654 // Parametre retourne : TRUE si une collision a eu lieu, FALSE sinon 656 //******************************************** 655 //***************************************************************************** 657 static sos_bool_t IsCollision(Point_t Org, Poi 656 static sos_bool_t IsCollision(Point_t Org, Point_t p, Point_t *Cheese) 658 { 657 { 659 Element_t * pMouse = pMap[Org.X + (Org 658 Element_t * pMouse = pMap[Org.X + (Org.Y * MAP_X)]; 660 Element_t * pElement; 659 Element_t * pElement; 661 660 662 //Tester les bordures de la map 661 //Tester les bordures de la map 663 if((p.X < 0)||(p.Y < 0)) return TRUE; 662 if((p.X < 0)||(p.Y < 0)) return TRUE; 664 663 665 if((p.Y >= MAP_Y)||(p.X >= MAP_X)) ret 664 if((p.Y >= MAP_Y)||(p.X >= MAP_X)) return TRUE; 666 665 667 pElement = pMap[p.X + (p.Y * MAP_X)]; 666 pElement = pMap[p.X + (p.Y * MAP_X)]; 668 667 669 //L'element est vide 668 //L'element est vide 670 if(pElement == NULL) return FALSE; 669 if(pElement == NULL) return FALSE; 671 670 672 //Si du fromage a ete trouve, stopper 671 //Si du fromage a ete trouve, stopper la recherche 673 if(IsSet(pMouse->Status, CHEESE_FOUND) 672 if(IsSet(pMouse->Status, CHEESE_FOUND)) return FALSE; 674 673 675 switch(pElement->Type) 674 switch(pElement->Type) 676 { 675 { 677 case CHEESE: 676 case CHEESE: 678 if(IsSet(pMouse->Statu 677 if(IsSet(pMouse->Status, MOUSE_FULL)) return TRUE; 679 //Indiquer que du from 678 //Indiquer que du fromage a ete trouve 680 Set(pMouse->Status, CH 679 Set(pMouse->Status, CHEESE_FOUND); 681 //Retenir la position 680 //Retenir la position du fromage 682 (*Cheese).X = p.X; 681 (*Cheese).X = p.X; 683 (*Cheese).Y = p.Y; 682 (*Cheese).Y = p.Y; 684 break; 683 break; 685 case INPUT: 684 case INPUT: 686 if(IsSet(pMouse->Statu 685 if(IsSet(pMouse->Status, MOUSE_EMPTY)) return TRUE; 687 //Remplir les reserves 686 //Remplir les reserves de fromage 688 Set(pMouse->Status, MO 687 Set(pMouse->Status, MOUSE_EMPTY); 689 Reset(pMouse->Status, 688 Reset(pMouse->Status, MOUSE_FULL); 690 pMouse->Color = SOS_X8 689 pMouse->Color = SOS_X86_VIDEO_FG_LTRED; 691 //Autoriser la creatio 690 //Autoriser la creation d'une autre souris 692 sos_ksema_up(& SemMous 691 sos_ksema_up(& SemMouse); 693 return TRUE; 692 return TRUE; 694 case OUTPUT: 693 case OUTPUT: 695 break; 694 break; 696 default : 695 default : 697 return TRUE; 696 return TRUE; 698 } 697 } 699 698 700 return FALSE;//Aucune collision 699 return FALSE;//Aucune collision 701 } 700 } 702 701 703 //******************************************** 702 //***************************************************************************** 704 // But du thread : Creer une souris et la plac 703 // But du thread : Creer une souris et la placer autour de l'entree 705 //******************************************** 704 //***************************************************************************** 706 static void MouseCreator(void) 705 static void MouseCreator(void) 707 { 706 { 708 while(1) 707 while(1) 709 { 708 { 710 sos_ksema_down(& SemMouse, NUL 709 sos_ksema_down(& SemMouse, NULL); 711 sos_ksema_down(& SemMap, NULL) 710 sos_ksema_down(& SemMap, NULL); 712 CreateMouse(); 711 CreateMouse(); 713 sos_ksema_up(& SemMap); 712 sos_ksema_up(& SemMap); 714 } 713 } 715 } 714 } 716 715 717 //******************************************** 716 //***************************************************************************** 718 // But de la fonction : Creer une souris et l' 717 // But de la fonction : Creer une souris et l'inserer dans la carte 719 // Entree : Aucune 718 // Entree : Aucune 720 // Parametre retourne : ERROR si memoire insuf 719 // Parametre retourne : ERROR si memoire insuffisante, FALSE si souris non 721 // cree, TRUE sinon 720 // cree, TRUE sinon 722 //******************************************** 721 //***************************************************************************** 723 static sos_ret_t CreateMouse(void) 722 static sos_ret_t CreateMouse(void) 724 { 723 { 725 Element_t * pElement; 724 Element_t * pElement; 726 unsigned int I; 725 unsigned int I; 727 726 728 Point_t p; 727 Point_t p; 729 728 730 for(I = 0; I < 8; I++) 729 for(I = 0; I < 8; I++) 731 {//Explorer tous les emplacements 730 {//Explorer tous les emplacements 732 p.X = 0; 731 p.X = 0; 733 p.Y = MAP_Y / 2; 732 p.Y = MAP_Y / 2; 734 switch(I) 733 switch(I) 735 {//Repere le deplacement 734 {//Repere le deplacement 736 case 0: 735 case 0: 737 p.Y++; 736 p.Y++; 738 break; 737 break; 739 case 1: 738 case 1: 740 p.X++; 739 p.X++; 741 p.Y++; 740 p.Y++; 742 break; 741 break; 743 case 2: 742 case 2: 744 p.X++; 743 p.X++; 745 break; 744 break; 746 case 3: 745 case 3: 747 p.Y--; 746 p.Y--; 748 p.X++; 747 p.X++; 749 break; 748 break; 750 case 4: 749 case 4: 751 p.Y--; 750 p.Y--; 752 break; 751 break; 753 case 5: 752 case 5: 754 p.Y--; 753 p.Y--; 755 p.X--; 754 p.X--; 756 break; 755 break; 757 case 6: 756 case 6: 758 p.X--; 757 p.X--; 759 break; 758 break; 760 case 7: 759 case 7: 761 p.X--; 760 p.X--; 762 p.Y++; 761 p.Y++; 763 break; 762 break; 764 } 763 } 765 if((p.X >= 0)&&(p.Y >= 0)&&(p. 764 if((p.X >= 0)&&(p.Y >= 0)&&(p.X < MAP_X)&&(p.Y < MAP_Y)) 766 {//L'emplacement est valide 765 {//L'emplacement est valide 767 pElement = pMap[p.X + 766 pElement = pMap[p.X + (p.Y * MAP_X)]; 768 if(pElement == NULL) 767 if(pElement == NULL) 769 {//Creer la souris 768 {//Creer la souris 770 pElement = (El 769 pElement = (Element_t *)sos_kmalloc(sizeof(Element_t), 0); 771 if(pElement != 770 if(pElement != NULL) 772 {//Initialiser 771 {//Initialiser l'entree 773 pEleme 772 pElement->Type = MOUSE; 774 Set(pE 773 Set(pElement->Status, MOUSE_EMPTY); 775 pEleme 774 pElement->Color = SOS_X86_VIDEO_FG_LTRED; 776 pEleme 775 pElement->P = p; 777 pEleme 776 pElement->Way = 0; 778 pEleme 777 pElement->ThreadID 779 = so 778 = sos_create_kernel_thread("Mouse", 780 779 (sos_kernel_thread_start_routine_t)Mouse, 781 !! 780 pElement); 782 if(pEl 781 if(pElement->ThreadID == 0) 783 { 782 { 784 783 sos_kfree((sos_vaddr_t)pElement); 785 784 pElement = NULL; 786 785 return -SOS_ENOMEM; 787 } 786 } 788 pMap[p 787 pMap[p.X + (p.Y * MAP_X)] = pElement; 789 MouseC 788 MouseCount++; 790 789 791 DrawPi 790 DrawPixel(p.X, p.Y, pElement->Color); 792 sos_x8 791 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 792 794 return 793 return SOS_OK; 795 } 794 } 796 } 795 } 797 } 796 } 798 } 797 } 799 return -SOS_EBUSY; 798 return -SOS_EBUSY; 800 } 799 } 801 800 802 //******************************************** 801 //***************************************************************************** 803 // C'est fini !!!! 802 // C'est fini !!!! 804 //******************************************** 803 //***************************************************************************** 805 804
| [ source navigation ] | [ diff markup ] | [ identifier search ] | [ general search ] |