1999/aeris.r

view sourceprint?
001/******************************************************************************
002 
003    CROBOT:    AERIS - 28/11/1999
004 
005    AUTORE:    Marco Giovannini
006 
007*******************************************************************************
008 
009  E' dura la vita per una matricola: con un solo mese di tempo a disposizione
010  e' difficile imparare ad usare CRobots e creare un robot competitivo. Quindi
011  e' molto, ma molto meglio copiare quelli gia' fatti e vedere cosa succede.
012  AERIS e' un robot standard, ma se volete proprio vedere come funziona eccovi
013  la sua scheda tecnica:
014 
015  SCHEDA TECNICA:
016      Come tutti, AERIS cerca di sopravvivere alle prime concitate fasi della
017      battaglia nascondendosi nell'angolo piu' vicino. Qui compie un movimento
018      triangolare sparando a tutto cio' che vede nel raggio del cannone con
019      due routines di fuoco: una e' quella classica di tox.r, l'altra invece
020      e' quella classica dei bambini (!) che viene richiamata durante la fase
021      di rallentamento del robot.
022      Chiaramente non si puo' continuare cosi' per sempre: il loop viene
023      interrotto se viene superata una soglia critica di danni (nel qual caso
024      si cambia quadrante) oppure non si colpisce nessuno per 16 volte
025      consecutive.
026      In quest'ultimo caso, se e' rimasto un solo altro robot in campo, viene
027      attivata la routine di attacco finale kamikaze() attinta a piene mani da
028      goblin.r, in cui si corre sulle diagonali sparando a vista. Questa
029      routine viene richiamata anche nel caso in cui passati circa 150000
030      cicli virtuali di clock non c'e' ancora stato un vincitore.
031 
032  La cosa bella di questo robot e' che, viste le efficienze degli altri
033  partecipanti al torneo, non avra' speranza di passare almeno il primo
034  girone: visto che si comporta come goblin.r, gli farete un mazzo tanto...
035  Che dire allora? Uno ci prova!!
036*/
037 
038int xx, yy;                                          /* variabili temporanee */
039 
040int time;                         /* contatore per i cicli virtuali di clock */
041int quad;                              /* quadrante in cui si trova il robot */
042int max_dam;               /* massimo danno sopportabile prima di andare via */
043int counter;                  /* da quanto tempo e' che non si vede nessuno? */
044 
045int t_alfa;                                          /* variabile temporanea */
046int m_alfa;                                           /* angolo di movimento */
047int x_alfa, y_alfa, h_alfa;              /* orrizzontale, verticale, obliquo */
048 
049int c_alfa, c_rng;                            /* angolo del cannone e raggio */
050int o_alfa, o_rng;                    /* old angolo del cannone e old raggio */
051 
052 
053main()
054{
055    /* rileva in quale quadrante si trova: 0 se in basso a sinistra, 1 in
056    basso a destra, 2 in alto a destra, 3 in alto a sinistra */
057    quad = (xx = (loc_x() > 500)) + (yy = (loc_y() > 500)) + ((!xx && yy) * 2);
058 
059    wait();
060 
061    kamikaze();
062}
063 
064 
065init_loop()
066{
067    /* spostati nell'angolo del quadrante corrente */
068    if (quad == 0 || quad == 3) { x_alfa = 0; while (loc_x() > 100) go(180); }
069        else { x_alfa = 180; while (loc_x() < 900) go(0); }
070    stop();
071    if (quad >= 2) { y_alfa = 90; while (loc_y() < 900) go(90); }
072        else { y_alfa = 270; while (loc_y() > 100) go(270); }
073    stop();
074 
075    h_alfa = 495 - 90*quad;
076    max_dam = damage() + 20;
077}
078 
079 
080wait()
081{
082    init_loop();
083    while (counter < 16) {
084        while (damage() < max_dam && counter < 16) {
085            /* movimento in orrizzontale */
086            while (loc_x() < 150 || loc_x() > 850) go(x_alfa); stop();
087            /* in obliquo */
088            while (loc_x() > 100 && loc_x() < 900) go(h_alfa); stop();
089            /* in verticale */
090            while (loc_y() > 100 && loc_y() < 900) go(y_alfa); stop();
091 
092            if (++time > 80)            /* se ti sei stufato di aspettare... */
093                if (damage() < 80) kamikaze(); else time = 0;
094        }
095 
096        if (counter >= 16) {                   /* se non hai trovato nessuno */
097            int t;                    /* controlla che non siate solo in due */
098            c_alfa = -10;
099            while (c_alfa < 710) if (scan(c_alfa += 20, 10)) ++t;
100            if (t > 2) counter = 0;          /* senno' continua ad aspettare */
101        } else {                              /* altrimenti cambia quadrante */
102            t_alfa = quad*90;      /* controlla che non ci sia gia' qualcuno */
103            if (scan(t_alfa + 350, 10) || scan(t_alfa + 10, 10)) {
104                if (!(scan(t_alfa + 80, 10) || scan(t_alfa + 100, 10)))
105                    { quad = (quad + 3) % 4; init_loop(); }  /* quello prima */
106            } else { quad = (quad + 1) % 4; init_loop(); }    /* quello dopo */
107        }
108    }
109}
110 
111 
112kamikaze()
113{
114    m_alfa = 45 + quad*90;                      /* direzione della diagonale */
115    while (1) {
116        while (loc_x() < 450 || loc_x() > 550) go(m_alfa); stop(); /* centro */
117        drive(m_alfa += 180, 100);
118 
119        if (scan(m_alfa + 350, 10) || scan(m_alfa + 10, 10)) {
120            if (scan(m_alfa + 80, 10) || scan(m_alfa + 100, 10)) m_alfa += 270;
121                else m_alfa += 90;
122            stop();
123        }
124 
125        while (loc_x() < 850 && loc_x() > 150 &&
126               loc_y() < 850 && loc_y() > 150) go(m_alfa); stop();
127        m_alfa += 180;
128    }
129}
130 
131 
132go(dir)
133{
134    drive(m_alfa = dir, 100);
135    if (o_rng = scan(c_alfa, 10)) {
136        if (o_rng > 700) { c_alfa += 40; ++counter; return; }  /* e' lontano */
137 
138        if (scan(c_alfa + 355, 1)) c_alfa += 355;
139        if (scan(c_alfa + 5,   1)) c_alfa += 5;
140        if (scan(c_alfa + 357, 1)) c_alfa += 357;
141        if (scan(c_alfa + 3,   1)) c_alfa += 3;
142        if (scan(c_alfa + 359, 1)) c_alfa += 359;
143        if (scan(c_alfa + 1,   1)) c_alfa += 1;
144 
145        if (o_rng = scan(o_alfa = c_alfa, 10)) {
146            if (scan(c_alfa + 355, 1)) c_alfa += 355;
147            if (scan(c_alfa + 5,   1)) c_alfa += 5;
148            if (scan(c_alfa + 357, 1)) c_alfa += 357;
149            if (scan(c_alfa + 3,   1)) c_alfa += 3;
150            if (scan(c_alfa + 359, 1)) c_alfa += 359;
151            if (scan(c_alfa + 1,   1)) c_alfa += 1;
152 
153            if (c_rng = scan(c_alfa, 10)) {
154  cannon( c_alfa+(c_alfa-o_alfa)*((1200+c_rng)>>9)-(sin(c_alfa-m_alfa)>>14),
155          (c_rng*160)/(160+o_rng-c_rng-(cos(c_alfa-m_alfa)>>12)) );
156                counter = 0;
157                return;
158            }
159        }
160    }
161    hunt();                           /* non c'e' nessuno? cerca li' intorno */
162}
163 
164 
165stop()
166{
167    drive(m_alfa, 0);
168    while (speed() > 40) {
169        if (c_rng = scan(c_alfa, 10)) {
170            if (c_rng > 700) { c_alfa += 40; ++counter; }
171            else {
172                if (o_rng = scan(c_alfa += 5, 5)) cannon(c_alfa, o_rng);
173                    else cannon(c_alfa += 350, c_rng);
174                counter = 0;
175            }
176        } else hunt();
177    }
178}
179 
180 
181hunt()
182{
183    if (scan(c_alfa += 340, 10)) return;                  /* guarda a destra */
184    if (scan(c_alfa += 40, 10)) return;                 /* guarda a sinistra */
185    c_alfa += 40;
186}