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