Cómo pasar el último nivel del juego de programación en lenguaje de bloques
var cs1 = 0;
var cs2 = 180;
mientras(verdadero){
var aleatorio = Math.random( )*360;
mover(aleatorio);
cerrar(aleatorio);
}
función mover(aleatorio){
nadar(cs1);
}
función cerrar(aleatorio){
if(scan(cs1,20)<=70 ){
if(scan(cs2,20)<=70){
cs2 = cs1-15
cañón(cs1-5,scan( cs1-10,10))
}else{
cs1 += 5;
cs2 = cs1-15; (cs1-5,scan(cs1-10,10))
}
}si no (scan(cs2,20)<=70){
cs1 -= 5;
cs2 = cs1-15;
cañón(cs1-5,scan(cs1-10,10))
}else {
cs1 += 20
}
}
—————————————— ——
Declaración de derechos de autor: este artículo es un artículo original del blogger de CSDN "Cats Don't Cry" y sigue el acuerdo de derechos de autor CC 4.0 BY-SA. Adjunte el enlace de la fuente original y esta declaración al reimprimir. .
Enlace original:
/*francotirador*/
/*estrategia: ya que un escaneo de todo el campo de batalla se puede hacer en 90 */
/* grados desde una esquina, el francotirador puede escanear el campo rápidamente */
/* variables externas, que pueden ser utilizadas por cualquier función */
var corner. = 0; /* esquina actual 0, 1, 2 o 2 */
var sc = 0; /* inicio del escaneo actual */
var rango; objetivo */
/* inicializar la información de la esquina */
/* ubicación x e y de una esquina y grado de escaneo inicial */
var c1x = 2, c1y = 2, s1 = 0;
var c2x = 2, c2y = 98, s2 = 270;
var c3x = 98, c3y = 98, s3 = 180 ;
var c4x = 98, c4y = 2, s4 = 90;
var más cercano = Infinity;
new_corner(); esquina */
var d = daño() /* obtener el daño actual */
var dir = sc /* dirección inicial del escaneo */
while (true) { /* el bucle se ejecuta para siempre */
while (dir < sc + 90) { /* escanea a través de un rango de 90 grados */
range = scan(dir , 2); /* mira una dirección */
if (range <= 70) {
while (range > 0) { /* sigue disparando mientras estés dentro del alcance */
más cercano = rango; /* establecer la bandera más cercana */
cannon(dir, rango /* fuego */
rango = scan(dir); , 1); /* comprobar el objetivo nuevamente */
si (d + 15 > daño()) /* sufrió varios golpes, */
rango = 0; nuevo rincón */
}
dir -= 10; /* escaneo de copia de seguridad, en caso */
}
dir += 2;* incremento de escaneo */
if ( d != daño()) { /* comprobar el daño sufrido */
new_corner(); /* estamos golpeados, muévete ahora */
d = daño() ;
dir = sc;
}
}
if (closest == Infinity) { /* comprueba si hay objetivos en rango */
new_corner(); /* nada, moverse a una nueva esquina */
d = daño();
dir = sc;
} else { /* objetivos dentro del alcance, reanudar */
dir = sc;
}
más cercano = Infinity;
}
/* nueva función de esquina para moverse a una esquina diferente */
función new_corner() {
var x, y;
var rand = Math.floor(Math.random() * 4); /* elige una esquina aleatoria */
if (rand == corner) /* pero hazlo diferente que la */
esquina = (rand + 1) % 4;/* esquina actual */
else
esquina = rand;
if (corner == 0) { /* establecer nuevos x,y e iniciar el escaneo */
x = c1x;
y = c1y;
sc = s1;
}
if (esquina == 1) {
x = c2x;
y = c2y ;
sc = s2;
}
si (esquina == 2) {
x = c3x;
y = c3y;
sc = s3;
}
if (esquina == 3) {
x = c4x;
y = c4y;
sc = s4;
}
/* encuentra el rumbo que necesitamos para llegar al esquina deseada */
var
angle = plot_course(x,y);
/* iniciar el tren de transmisión, velocidad máxima */
/* seguir viajando hasta que estemos a 15 metros */
/* la velocidad se comprueba en caso de que nos topemos con la pared, otro robot */
/* no es muy bueno, ya que no hacemos nada mientras nos movimos */
while (distancia ( getX(), getY(), x, y) > 15)
drive(angle, 100);
/* reduce la velocidad y avanza lentamente el resto del camino * /
while (distancia(getX(), getY(), x, y) > 1)
drive(angle, 20);
/* detener conducir, debe avanzar por inercia el resto del camino */
drive(angle, 0);
} /* end of new_corner */
/ * fórmula pitagórica clásica de distancia */
función distancia(x1, y1, x2, y2) {
var x = x1 - x2;
var y = y1 - y2;
return Math.sqrt((x * x) + (y * y));
}
/* trazar la función del curso, return grado rumbo a */
/* llegar al destino x, y; usa la función trigonométrica atan() */
función plot_course(xx, yy) {
var d;
var x,y;
var curx, cury;
curx = getX() /* obtener ubicación actual */
cury = getY();
x = curx - xx;
y = cury - yy;
/* atan solo devuelve - 90 a +90, así que descubre cómo usar */
/* el valor atan() */
if (x == 0) { /* x es cero, moverse hacia el norte o hacia el sur */
if (yy > cury)
d = 90 /* norte */
else
<; p> d = 270; /* sur */} else {
if (yy < cury) {
if (xx > curx)
d = 360 + Math.atan_deg(y / x /* sureste, cuadrante 4 */
else
} else {
if (xx > curx)
d = Math.atan_deg(y / x); /* noreste, cuadrante 1 */
else
d = 180 + Math.atan_deg(y / x); /* noroeste, cuadrante 2 */
}
}
return d;
}
/* conejo */
// el conejo corre por el campo, aleatoriamente y nunca dispara; úsalo como objetivo.
/* go: ve al punto especificado. */
función go (dest_x, dest_y) {
var curso = plot_course(dest_x, destino_y);
while (distancia(getX(), getY (), dest_x, dest_y) > 5) {
conducir(curso, 25);
}
mientras (velocidad() > 0) {
unidad(rumbo, 0);
}
}
/* fórmula de distancia */
función distancia(x1, y1, x2, y2) {
var x = x1 - x2;
var y = y1 - y2;
return Math. sqrt((x * x) + (y * y));
}
/* plot_course - descubre qué encabezado ir */
función plot_course(xx, yy) {
var d;
var curx = getX();
var cury = getY();
var x = curx - xx;
var y = cury - yy;
if (x == 0) {
if (yy > cury) {
d = 90;
} más {
d = 270;
}
} else {
if (yy < cury) {
if (xx > curx) {
d = 360 + Math.ata
n_deg(y/x);
} else {
d = 180 + Math.atan_deg(y/x);
}
} más {
if (xx > curx) {
d = Math.atan_deg(y/x);
} más {
d = 180 + Math.atan_deg(y / x);
}
}
}
devuelve d ;
}
while (true) {
// Ve a algún lugar del campo.
var x = Math.random( ) * 100;
var y = Math.random() * 100;
go(x, y);
}
/* contador */
/* escanea en sentido contrario a las agujas del reloj (grados crecientes) */
/* se mueve cuando se golpea */
var rango;
var last_dir = 0;
var res = 2;
var d = daño();
var ángulo = Math.random() * 360;
mientras (verdadero) {
while ((rango = escaneo(ángulo, res)) != Infinito) {
if (range > 70) { /* fuera del rango, dirígete hacia él */
drive(angle, 50);
var i = 1;
while (i++ < 50) /* usa un contador para limitar el tiempo de movimiento */
;
drive (angle, 0);
if ( d != daño()) {
d = daño();
ejecutar();
}
ángulo -= 3;
} else {
while (!cannon(ángulo, alcance))
;
if (d != daño ()) {
d = daño();
ejecutar();
}
ángulo -= 15; p>
}
}
if (d != daño()) {
d = daño();
ejecutar();
}
ángulo += res;
ángulo %= 360;
}
/* run se mueve alrededor del centro del campo */
función run() {
var i = 0;
var x = getX();
var y = getY();
if (last_dir == 0) {
last_dir = 1;
if (y > 51) {
drive(270, 100);
while (y - 10 < getY() && i++ < 50)
;
conducir(270, 0);
} más {
conducir(90, 100);
mientras (y + 10 > getY() && i++ < 50)
;
unidad(90, 0);
}
} else {
last_dir = 0;
if (x > 51) {
drive(180, 100);
while (x - 10 < getX() && i++ < 50)
;
unidad(180, 0);
} más {
conducir(0, 100);
mientras (x + 10 > getX() && i++ < 50)
;
conducir(0, 0 );
}
}
}
/* rook.r - escanea el campo de batalla como una torre, es decir, solo 0 ,90,180,270 */
/* se mueve solo horizontalmente, pero mira horizontal y verticalmente */
/* se mueve al centro del tablero */
if (getY () < 50) {
while (getY() < 40) /* detenerse cerca del centro */
conducir(90, 100 /* comenzar a moverse */
} else {
while (getY() > 60) /* detenerse cerca del centro */
drive(270, 100) /* comenzar a moverse */
}
conducir(0, 0);
mientras (velocidad() > 0)
;
/* inicializar parámetros iniciales */
var d = daño();
var curso = 0;
var límite = 99;
conducir(curso, 30);
/* bucle principal */
while(true) {
/* mirar en todas direcciones */
look(0);
look(90);
look(180);
look(270);
/* si está cerca del final del campo de batalla, cambia de dirección */
if (curso == 0 ) {
if (getX() > límite || velocidad() == 0)
cambio();
}
else {
if (getX() < límite || velocidad() == 0)
cambio();
}
}
/* mira hacia algún lugar y dispara el cañón repetidamente al objetivo dentro del alcance */
function look(deg) {
var range;
while ((rango = escaneo(grados, 4)) <= 70) {
conducir(rumbo, 0);
cañón(grados, rango) ;
if (d + 20 != daño()) {
d = daño();
cambio();
}
}
}
cambio de función() {
if (curso == 0) {
límite = 1;
rumbo = 180;
} else {
límite = 99;
rumbo = 0;
}
conducir(rumbo, 30);
}
var oeste = false;
mientras ( verdadero) {
x();
grados();
}
función x(){
for(var i = 0; i <= 360; i += 20){
if(scan(i, 20) <= 70){
cañón(i , scan(i, 20));
}
}
}
función deg(){
if (oeste) {
if (getX() > 25) {
nadar(180, 100);
} else {
oeste = false;
nadar(0, 0);
}
} más {
> if (getX() < 75) {
nadar(0, 100);
} else {
oeste = verdadero;
nadar(0, 0);
}
}
}