Red de conocimiento informático - Material del sitio web - Cómo pasar el último nivel del juego de programación en lenguaje de bloques

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

d = 180 + Math.atan_deg(y / x); /* suroeste, cuadrante 3 */

} 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);

}

}

}