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