2003/scilla.r
001 | /* |
002 | \/\/\/\/\/\/\/\/\/\/\/\/\/ |
003 |
004 | S C I L L A . r |
005 |
006 | /\/\/\/\/\/\/\/\/\/\/\/\/\ |
007 |
008 | di Pizzocaro Marco |
009 |
010 |
011 | Torneo di C Robots 2003 |
012 | C Robots: Scilla.r |
013 | Categoria: Micro |
014 | VB: 494 (24%) |
015 |
016 | Autore: Pizzocaro Marco |
017 |
018 | SCHEDA TECNICA |
019 |
020 | Tattica & Strategia |
021 | Ho sviluppato il robot attorno ad una precisa tattica: raggiunto l'angolo |
022 | pi� vicino, Scilla inizia ad oscillare solo orizzontalmente, con un |
023 | movimento "ad underscore", seguendo questa idea: |
024 | se l'oscillazione avviene abbastanza appiccicata alla parete dell'arena, |
025 | in una sola direzione, probabilmente uno dei due robot vicini (a meno che |
026 | non sia particolarmente aggressivo o furbo) far� fatica a colpire. Cos� |
027 | Scilla tenta di far diventare quella che era una sfida contro i due bot |
028 | negli angoli adiacenti, un duello con quello che trova in orizzontale. |
029 | Ignorando completamente il bot sulla stessa verticale, Scilla si concentra, |
030 | con oscillazioni abbastanza lunghe, sul suo nemico prescelto (che si spera |
031 | venga messo alle strette avendo da combattere contro 2 nemici). |
032 | Praticamente si tratta di un estremizzazione del fatto che i crobot moderni |
033 | non perdono mai l'avversario puntato: Scilla oltre a questo aggiunge la |
034 | possibilit� di avere l'avversario per pi� tempo possibile a portata di fuoco |
035 | (mentre con una oscillazione ad L, per esempio, siamo praticamente certi |
036 | che il nemico sar� fuori tiro quando il robot si muove sul lato opposto ad |
037 | esso). |
038 | Un oscillazione del genere non � affatto difensiva, ma esiste il piccolo |
039 | vantaggio di prenderle (spero) solo da uno solo dei due bot vicini, che |
040 | magari ha deciso per fatti suoi di sparare ad un altro robot. |
041 | La scelta della lunghezza dell'oscillazione (che si basa sulla distanza del |
042 | nemico verso cui si oscilla) � spudoratamente copiata da Rudolf_6, |
043 | a cui, diciamo, mi sono largamente "ispirato". Forse avrei dovuto |
044 | controllare tra i robot dell'anno scorso se esistevano robot pi� moderni da |
045 | cui attingere, ma ispirarsi a Rudolf_6 ha il vantaggio che so gi� come |
046 | funziona. Rispetto a Rudolf_6, Scilla � pi� aggressivo e si muove per |
047 | un tratto pi� lungo di arena. |
048 | Pur non essendo un movimento nuovo, mi sembra che fino ad ora sia stato |
049 | poco sfruttato, cos� posso almeno dire di non aver proposto qualcosa di |
050 | banale. |
051 |
052 |
053 | Dunque Scilla inizia ogni incontro raggiungendo l'angolo pi� vicino. |
054 | Poi inizia inizia a compiere un oscillazione orizzontale Rudolf_6-like, |
055 | sparando al nemico che si trova sulla stessa orizzontale, |
056 | secondo la distanza che li separa, come descritto sopra. |
057 | Dopo un tot di cicli, se non ha subito troppi danni allunga |
058 | leggermente l'oscillazione. |
059 | Quando il nemico prescelto muore o si allontana, l'oscillazione si allunga |
060 | a coprire tutto il lato dell'arena, nel tentativo di sfuggire il pi� |
061 | possibile ai colpi degli avversari rimasti. Continuer� cos� fino alla fine |
062 | del match sperando che gli avversari si distruggano reciprocamente. |
063 |
064 | Quindi non c'� routine finale o da f2f. |
065 | Scilla occupa con il codice del movimento in orizzontale tutti i 500 VB |
066 | concessimi. Ci� non mi permette di aggiungere una routine finale. Invano |
067 | ho tentato di aggiungerne una semplicissima, basata magari solo sul numero |
068 | di cicli. Scilla continuer� finch� vince o muore la sua oscillazione da 4vs4. |
069 | Ci� ne costituisce il maggior difetto (pi� o meno risolto nei miei altri |
070 | robot di quest'anno): Scilla ha un pessimo rendimento in f2f e ottiene un |
071 | numero spropositato di pareggi in 4vs4 (non ha modo di colpire gli |
072 | avversari sul lato opposto). |
073 |
074 |
075 |
076 | Routine di Fuoco |
077 | Scilla usa un'unica routine di fuoco, la fire(), che deriva da quella del |
078 | mio scarso robot dell'anno scorso (supernova.r) con qualche accorgimento |
079 | di cui mi sono dimenticato. A sua volta quella dell'anno prima mi sembra |
080 | derivare da arale.r. E' quasi temporizzata con il movimento (impiega circa |
081 | 78 cicli virtuali), ricava al volo l'angolo e corregge leggermente il range. |
082 | Contiene un istruzione che gli fa cambiare puntamento se il nemico � troppo |
083 | lontano (range<1050), ma dovrebbe funzionare solo con il bot sulla diagonale |
084 | (sempre troppo lontano per poterlo colpire). Inoltre � pronto a tornare |
085 | al nemico originario sulla stessa orizzontale se per sbaglio stava mirando |
086 | da altre parti (tramite scan(dir,10)). |
087 |
088 | COMMENTO |
089 | Anche se pu� ottenere qualche risultato in 4vs4, il suo rendimento in f2f |
090 | � scandaloso. |
091 |
092 | */ |
093 |
094 | int ang, range, xora, dist, aq, oscar; |
095 | int t; |
096 | int a, dir; |
097 |
098 | main() |
099 | { |
100 | if (loc_y()>500) up(940); else dn(60); |
101 | if (loc_x()>500) {dx(920); ang=180;} else sx(80); |
102 |
103 |
104 | while (1) |
105 | { |
106 | if (loc_x()>500){ |
107 | while (speed()>49); |
108 | drive(dir=180,100); |
109 | /*if (oldr&&oldr<800) adef();*/ |
110 | if (!(dist=scan(170,10))) if (!(dist=scan(190,10))) a=dist=900; |
111 | if ((aq=dist-700+oscar)>0) xora=loc_x()-aq; |
112 | else xora=870; |
113 | sx(xora); |
114 | dx(925); |
115 | } |
116 | else { |
117 | while (speed()>49); |
118 | drive(dir=0,100); |
119 | /*if (oldr&&oldr<800) bdef();*/ |
120 | if (!(dist=scan(10,10))) if (!(dist=scan(350,10))) a=dist=900; |
121 | if ((aq=dist-700+oscar)>0) xora=aq+loc_x(); |
122 | else xora=130; |
123 | dx(xora); |
124 | sx(75); |
125 | } |
126 |
127 | if (++t>20||range>850) |
128 | { |
129 | oscar=40*((t>25)); |
130 | if (a&&t>2) if (!scan(0,10)&&!scan(180,10)) {oscar=500; t+=2;} |
131 | if (damage()>80) oscar=0; |
132 | /*if(t>150) {up(500); dn(500);}*/ |
133 | a=0; |
134 | } |
135 |
136 | } |
137 |
138 |
139 | } |
140 |
141 | fire() |
142 | { |
143 |
144 | if ((range=scan(ang,7))&&range<1050) |
145 | { |
146 | if (range<100) return cannon(ang,range); |
147 | else |
148 | cannon(ang+=4*(!(scan(ang+355,6)))+356*(!(scan(ang+5,6))), 3*scan(ang,10)-2*range); |
149 | } |
150 | else if (scan (ang-=16,10)); |
151 | /* else if (scan (ang+=32,10));*/ |
152 | else if (scan (dir,10)) ang=dir; |
153 | else if (!scan (ang+=32,10)) ang+=30; |
154 | } |
155 |
156 |
157 |
158 | up(limt) { while (loc_y()<limt) {drive(90,100);fire();}drive(90,0);} |
159 | dn(limt) { while (loc_y()>limt) {drive(270,100);fire();}drive(270,0);} |
160 | dx(limt) { while (loc_x()<limt) {drive(0,100);fire();}drive(0,0);} |
161 | sx(limt) { while (loc_x()>limt) {drive(180,100);fire();}drive(180,0);} |