1993/puyopuyo.r

view sourceprint?
001/* -------------------------------------------------------------- */
002/*  ROBOT:          PuyoPuyo                                      */
003/*                                                                */
004/*  Programma terminato il 30 agosto 1993                         */
005/*                                                                */
006/* -------------------------------------------------------------- */
007 
008 
009 
010 
011 
012 
013 
014 
015 
016 
017int     dir_sca,  /*direzione dello scan*/
018         
019        dir_rob,  /*direzione del robot*/
020         
021        old_dst,  /*memorizza il valore restituito dall'ultima funzione di scan*/
022         
023        dam_old,  /*qui viene memorizzato il danno */
024         
025        target,   /*distanza del bersaglio*/
026         
027        a,        /*indicatore di pericolo(per valori negativi inizia l'emergenza*/
028         
029        switch,   /*assume il valore 1 durante le emergenze e 0 quando non c'� pericolo*/
030         
031        schiavo,       
032        servo,
033         
034        spia;     /*variabile usata per invertire il moto del robot in situzioni di pericolo*/
035         
036main()
037{
038        schiavo=0;     
039        servo=0;
040        switch=0;
041        a=1;
042        inizio(); 
043           
044         
045         
046        while(1)
047        {
048                muoviy(90,270,10,0,50);                             
049                latobasso();
050                 
051                muovix(0,180,10,50,100);
052                 
053        }
054}
055spara(min,max,step)
056int     min,      /* i primi due parametri indicano gli estremi dell'area da controllare*/
057        max,
058        step;     /* apertura dello scan */
059{
060        /* la funzione di sparo si limita a controllare l'area indicata(min max)             */
061        /* variando la direzione dello scan di un angolo 2*step.                             */
062        /* Quando il bersaglio viene trovato la direzione dello scan non viene modificata    */
063        /* fino a quando il bersaglio � inquadrato dallo scan oppure fino a quando           */                         
064        /* si ritiene utile sparargli                                                        */
065        /* l'ultima condizione � verificata dallo stato della variabile switch               */
066        /* Quando c'e' pericolo switch � uguale a zero e quindi vengono trascurati i bersagli */
067        /* pi� distanti(target<400) per concentrarsi su quelli vicini                       */
068        /* Quando non c'e pericolo non si trascura alcun bersaglio                           */      
069         
070        if(switch==0)   /*se c'e' pericolo*/
071        {
072                if ((target = scan(dir_sca, step))!=0 && target<400)
073                {
074                        if (old_dst < target)
075                        {                                       /* la gittata cambia se il*/
076                               cannon(dir_sca, 8 * target / 7); /* bersaglio si allontana*/
077                               old_dst = target;                /* o si avvicina*/
078                         
079                        }
080                        else
081                        {
082                               cannon(dir_sca, 7 * target / 8);
083                               old_dst = target;/* si memorizza la distanza del bersaglio*/
084                                                /* per controllarne il movimento*/
085                        }
086                }
087                else
088                {
089                        dir_sca -= 2*step;
090                        if (dir_sca < min-10 || dir_sca > max+10)
091                              step=-step; /*si inverte l'incremento della direz dello scanner*/
092                         
093                        ++a;  /*non ci sono nemici quindisi diminusce lo stato di allerta*/
094                }                                       /* vedi funzioni tiro() ed emerchk()*/
095                 
096                sparads(dir_rob);
097        }
098        else if(switch==1)                              /* se non c'e' pericolo */
099        {
100                if ((target = scan(dir_sca, step))!=0)
101                {
102                        if (old_dst < target)
103                        {
104                                cannon(dir_sca, 8 * target / 7);
105                                old_dst = target;
106                                 
107                        }
108                        else
109                        {
110                                cannon(dir_sca, 7 * target / 8);
111                                old_dst = target;
112                                 
113                        }
114                }
115                else
116                {
117                        dir_sca -= 2*step;
118                        if (dir_sca < min-10 || dir_sca > max+10)
119                                step=-step;
120                         
121                }
122                 
123        }
124}
125 
126 
127muovix(min,max,step,mind,maxd)  /* questa funzione fa muovere orizzontalmente il robot*/
128int     min,
129        max,
130        step,                   /* per il significato dei parametri vedi muoviy()   */
131        mind,
132        maxd;
133{
134                                /* la funzione si comporta in maniera analoga a muoviy()*/
135        spia=1;
136        schiavo=0;
137        servo=0;
138        dam_old=damage();
139 
140                while(1)
141                {      
142                        spia=1;
143                        if(loc_x()<850 && spia==1)
144                        {
145                                dir_rob=0;
146                                drive(dir_rob,100);
147                        }
148                        while(loc_x()<850 && spia==1)
149                        {
150                                if(damage()<mind || damage()>=maxd)
151                                        return(0);
152                                spara(min,max,step);
153                                 
154                                 
155                                emerchk();
156 
157                                tiro();
158 
159                        }
160                        spia=1;   
161                        drive(dir_rob,0);
162                        while(speed()>0)          
163                                spara(min,max,step);
164                                              
165                        if(loc_x()>150 && spia==1)
166                        {                              
167                                dir_rob=180;           
168                                drive(dir_rob,100);
169                        }                              
170                        while(loc_x()>150 && spia==1)
171                        {                              
172                                if(damage()<mind || damage()>=maxd)
173                                        return(0);     
174                                spara(min,max,step);
175                                 
176                                emerchk();
177 
178                                tiro();
179                        }
180                        drive(180,0);
181                        while(speed()>0)
182                                spara(min,max,step);
183                         
184                }     
185}
186 
187 
188muoviy(min,max,step,mind,maxd)  /* questa funzione fa muovere verticalmente il robot    */
189int     min,                    /* estremi dell'area da                                 */
190        max,                    /* controllare                                          */
191        step,                   /* incremento della direzione dello scan                */
192        mind,                   /* estremi dell'intervallo entro il quale pu� variare il*/
193        maxd;                   /* danno prima che il controllo si restituito a main()  */                            
194{
195                                 
196        spia=1;
197        schiavo=0;
198        servo=0;
199        dam_old=damage();
200         
201                while(1)
202                {      
203                        spia=1;
204                        if(loc_y()<850 && spia==1)
205                        {
206                                dir_rob=90;        /*  il robot inverte la direzione*/
207                                drive(dir_rob,100);/* e va in basso*/
208                        }
209                        while(loc_y()<850 && spia==1)
210                        {
211                                if(damage()<mind || damage()>=maxd) /*se il danno esce dall'intervallo si ritorna a main()*/
212                                        return(0);
213                                spara(min,max,step);/*richiama la funzione di sparo*/
214                                emerchk();/*vedi descrizione della funz*/
215                                tiro();   /*vedi descrizione della funz*/     
216 
217                        }
218                        spia=1;    /*il diversivo per l'emergenza � stato attivato*/
219                        drive(dir_rob,0);    /* il robot si ferma*/
220                        while(speed()>0)     /* mentre rallenta*/     
221                                spara(min,max,step); /* spara*/
222                                              
223 
224        /*il seguente gruppo di istruzioni � analogo al precedente */
225        /*ma stavolta il robot va in alto                          */
226 
227 
228                        if(loc_y()>150 && spia==1)
229                        {                              
230                                dir_rob=270;           
231                                drive(dir_rob,100);
232                        }                              
233                        while(loc_y()>150 && spia==1)
234                        {                              
235                                if(damage()<mind || damage()>=maxd)
236                                        return(0);     
237                                spara(min,max,step);
238                                 
239                                emerchk();
240 
241                                tiro();
242                                 
243                        }
244                        drive(dir_rob,0);
245                        while(speed()>0)
246                               spara(min,max,step);
247                         
248                }     
249}
250 
251emerchk() /*questa funzione controlla periodicamente i danni subiti dal robot e se superano*/
252{         /*un certo valore azzera la variabile spia, facendo cos� cambiare direzione al robot.*/
253          /*Inoltre attiva il segnale di emergenza (a<0) che viene controllato da tiro()*/
254         
255         
256                ++schiavo;
257                if(schiavo>=4)
258                {
259                        schiavo=0;
260                        if(damage()-dam_old>=7) /* emergenza!! */
261                        {
262                                spia=0;
263                                a=-4;
264                        }
265                        else
266                                a=1;            /*fine emergenza*/
267                        dam_old=damage();
268                }
269}        
270 
271 
272tiro() /*questa funzione controllla i messaggi di emerchk() e modifica la procedura di */                     
273{      /*sparo se c'e' pericolo e la riporta in condizioni normali quando il pericolo � finito*/
274                 
275                 
276                if(a<=0 && damage()<70)
277                        switch=0;       /*pericolo controlla solo vicino*/
278                else if(a>0 || damage()>=70)
279                        switch=1;       /*non c'e' pericolo controlla normalmente*/
280                if(a<=0 && damage()>=70)
281                        a=1;           
282}       
283sparads(lato)
284int lato;
285{
286        int bers;
287        if((bers=(scan(dir_rob,10)))!=0)
288        {
289                old_dst=bers;
290                dir_sca=dir_rob;
291        }
292        else if((bers=(scan(dir_rob+180,10)))!=0)
293        {
294                dir_sca=dir_rob+180;
295                old_dst=bers;
296        }
297        return(1);
298}
299 
300inizio()                               /* questa funzione porta il robot */
301{                                      /* sul lato sinistro del campo    */
302        drive(0,100);
303        while(loc_x()<940)
304        {
305                 while(loc_x()<900)       
306                        spara(0,359,10);
307        }
308        drive(0,0);        
309        while(speed()>49);      
310        return(1);
311}
312 
313latobasso()                              /* questa funzione porta il robot */
314{                                        /* sul lato basso del campo    */
315        drive(dir_rob,0);
316        while(speed()>49);             
317        drive(270,100);                  /*vai gi�*/
318        while(loc_y()>80)
319                spara(270,270+179,10);
320        drive(270,0);
321        while(speed()>49);      
322 
323        drive(180,100);                 /*vai a sinistra*/
324        while(loc_x()>100)
325                spara(180,359,10);
326        drive(180,0);
327        while(speed()>49);
328                 
329}