SimpleOS

LXR

Navigation



Site hébergé par : enix

The LXR Cross Referencer for SOS

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

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

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