API tools faq
paste
Advertisement
manhattanxl

Simulador de ensamblador (Abstracto), Javascript

manhattanxl
Apr 11th, 2016
165
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
HTML 19.87 KB | None | 0 0
raw download clone embed print report
  1. <html>
  2. <head>
  3.   <title>Intento JS interprete? </title>
  4.   <style type="text/css" media="screen">
  5.     #big {
  6.         background: #000000;
  7.         width: 100px;
  8.         height: 100px;
  9.         position: relative;
  10.     }
  11.     #-codigo {
  12.         position: relative;
  13.         top: 0;
  14.         right: 0;
  15.         bottom: 0;
  16.         left: 0;
  17.         height: 250px;
  18.     }
  19.     /*<![CDATA[*/
  20.  
  21.     .content-columns {
  22.         /* Setting relative positioning allows for
  23.         absolute positioning for sub-classes */
  24.         position: relative;
  25.         padding-top: 1em;
  26.     }
  27.     .content-column-left {
  28.         /* Value for IE/Win; will be overwritten for other browsers */
  29.         width: 47%;
  30.         padding-right: 3%;
  31.         float: left;
  32.         padding-bottom: 2em;
  33.     }
  34.     .content-column-left hr {
  35.         display: none;
  36.     }
  37.     .content-column-right {
  38.         /* Values for IE/Win; will be overwritten for other browsers */
  39.         width: 47%;
  40.         padding-left: 3%;
  41.         float: left;
  42.         padding-bottom: 2em;
  43.     }
  44.     .content-columns>.content-column-left, .content-columns>.content-column-right {
  45.         /* Non-IE/Win */
  46.     }
  47.     img {
  48.         border: 2px solid #fff;
  49.         padding: 2px;
  50.         margin: 2px;
  51.     }
  52.     a:hover img {
  53.         border: 2px solid #f50;
  54.     }
  55.     /*]]>*/
  56.   </style>
  57.   <script type="text/javascript">
  58.      
  59.     /* Contacto afperrens@gmail.com */
  60.     /* Observaciones previas; Para que funcione correctamente, el
  61.     navegador deberia estar al 100% de zoom, y preferiblemente no
  62.     deberian llamarse varias veces las funciones de setteo inicial
  63.     aunque ya estan cubiertos esos casos en el codigo
  64.    
  65.     VARIABLES GLOBALES QUE SE SETTEAN PREFERIBLEMENTE EN MAIN
  66.     variables que no pueden ser pasadas por parametro */
  67.     var globalCampo;
  68.     // puede que haya dos robots?
  69.     var globalRobot;
  70.     // ancho de las calles, para cambiar en caso de ser necesario, solo
  71.     // tocar esta (no tiene que ser un numero primo):
  72.     var globalSideBlock = 11;
  73.     // donde se guardan todos los comandos globales
  74.     var globalCom;
  75.  
  76.     // FUNCIONES DEL ROBOT
  77.     function drawRobot(campo){
  78.         if(document.getElementById("ROBOT") == null){
  79.           // Se genero Robot?, si no, continuo
  80.           // todas las ordenes que recibe de movimientos empiezan
  81.           // en una coordenada y luego dependiendo de la posicion
  82.           // se puede mover hacia arriba, abajo, izquierda o derecha
  83.           // siempre de a 10px; Para los movimientos de izquerda
  84.           // a derecha, solo se puede girar abajo o arriba si la
  85.           // posicion es multiplo de 20 o 0, lo mismo sucede con
  86.           // los movimientos de izquierda a derecha cuando se este
  87.           // moviendo de arriba hacia abajo
  88.           var robot = drawObjeto(campo,"#AAAAAA");
  89.           robot.id = "ROBOT";
  90.           robot.style.left = "0px";
  91.           robot.style.top = "0px";
  92.           robot.style.color = "#222DDD";
  93.           robot.style.fontSize = "8px";
  94.           robot.textContent = "R";
  95.           // creo una variable para saber la orientacion del robot
  96.           // del 1 al 4, por default 1
  97.           robot.orientacion = 1;
  98.           // ENERGIA DEL ROBOT, arranca con 100
  99.           robot.energia = 100;
  100.           return robot;
  101.         } else {
  102.             // por alguna extraña y misteriosa razon, javascript retorna
  103.             // un return aunque este dentro de un if que no se cumpla
  104.             // por mas redundante que parezca este else, es la unica
  105.             // manera de evitar un error si se llama dos veces la funcion
  106.             return globalRobot;
  107.         }
  108.       }
  109.     function moverRobot(robot,alertas){
  110.       // alertas determina si se avisa cuando colisiona o se cae, 1 true 0 false
  111.       // trabaja con el ROBOT que se definio anteriormente y dentro de campo
  112.       if(robot.energia != 0){ // tiene energia?
  113.          
  114.           if(robot.orientacion == 1 && ((parseInt(robot.style.top)%(globalSideBlock*2) == 0) || (parseInt(robot.style.top) == 0)) ){
  115.             robot.style.left = (parseInt(robot.style.left) + globalSideBlock).toString() + "px";
  116.                 }
  117.           if(robot.orientacion == 2 && ((parseInt(robot.style.left)%(globalSideBlock*2) == 0) || (parseInt(robot.style.left) == 0)) ){
  118.             robot.style.top = (parseInt(robot.style.top) + globalSideBlock).toString() + "px";
  119.                 }
  120.           if(robot.orientacion == 3 && ((parseInt(robot.style.top)%(globalSideBlock*2) == 0) || (parseInt(robot.style.top) == 0)) ){
  121.             robot.style.left = (parseInt(robot.style.left) - globalSideBlock).toString() + "px";
  122.                 }
  123.           if(robot.orientacion == 4 && ((parseInt(robot.style.left)%(globalSideBlock*2) == 0) || (parseInt(robot.style.left) == 0)) ){
  124.             robot.style.top = (parseInt(robot.style.top) - globalSideBlock).toString() + "px";
  125.                 }
  126.           // se cayo?
  127.           if(cayoRobot(robot) && alertas){
  128.               alert("[El robot se cayo del campo]\n## Colocandolo en posicion inicial \n" +
  129.                     "## Restaurando orientacion a derecha \n" +
  130.                     "## -10 de energia");
  131.               robot.energia -= 10;
  132.               }
  133.           // colisiono?
  134.           var col = colisionRobot(robot);
  135.           if(col && alertas){
  136.               alert("el robot ha colisionado con " + col);
  137.           }
  138.           // si no sucedio ningun error, se retorna true
  139.           return 1;
  140.           } else {
  141.               // alerta obligatoria
  142.               alert("ROBOT se ha quedado sin energia");
  143.               return 0;
  144.               }
  145.         }
  146.     function cayoRobot(robot){
  147.         if(!((0 <= parseInt(robot.style.top)) && (parseInt(robot.style.top) < parseInt(globalCampo.style.height))) ||
  148.             !((0 <= parseInt(robot.style.left)) && (parseInt(robot.style.left) < parseInt(globalCampo.style.width)))){
  149.                 // por alguna razon, Javascript no puede evaluar correctamente la condicion
  150.                 // (0 > parseInt(globalRobot.style.left) < parseInt(globalCampo.style.width)) retornando solo
  151.                 // el valor de la primera sentencia
  152.                 robot.style.top = 0;
  153.                 robot.style.left = 0;
  154.                 robot.orientacion = 1;
  155.                 // si esto sucede, se debe retornar false
  156.                 return 1;
  157.                 } else {
  158.                     return 0;
  159.                     }
  160.         }
  161.     function colisionaraRobot(robot){
  162.         /* no tengo ganas de escribir todo de nuevo, aparte reutilizamos codigo.
  163.         Esta funcion se adelanta un movimiento y determina si al frente de el
  164.         tiene un objeto a colisionar */
  165.         moverRobot(robot,0);
  166.         var col = colisionRobot(robot);
  167.         if(col != robot.id){
  168.             return col;
  169.             } else {
  170.                 return 0;
  171.                 }
  172.         // vuelvo a poner al robot apuntando al mismo lugar, en el mismo lugar
  173.         cambiarOrientacion(robot);
  174.         cambiarOrientacion(robot);
  175.         moverRobot(robot);
  176.         cambiarOrientacion(robot);
  177.         cambiarOrientacion(robot);
  178.         }
  179.     function colisionRobot(robot){
  180.         /* obtengo la posicion del robot y de alli obtengo el elemento
  181.         que hay ahi con elementFromPoint, si no es robot es un objeto
  182.         y lo retorno */
  183.         var elemento = document.elementFromPoint(getPosition(robot).x,getPosition(robot).y)
  184.         /* EN FIREFOX SI NO ESTA LA PANTALLA EN 100% NO PUEDE CORRECTAMENTE
  185.         UBICAR LA POSICION DEL OBJETO Y POR LO TANTO NO COLISIONA
  186.         NI MAS, NI MENOS % DE VISUALIZACION */
  187.         if(elemento.id != robot.id){
  188.             /* si no es robot, retorno el elemento, y que la funcion de
  189.             arriba gestione si le resta energia o no */
  190.             return elemento.id
  191.             } else {
  192.                 return 0;
  193.                 }
  194.         }
  195.    function cambiarOrientacion(robot){
  196.      if(robot.orientacion == 4) robot.orientacion = 1;
  197.        else robot.orientacion += 1;
  198.      }
  199.  
  200.  
  201.     // FUNCIONES GENERALES (CAMPO Y OTRAS)
  202.    function drawCampo(campo,xIt,yIt){
  203.      if(document.getElementById("CAMPO") == null){
  204.         /* Se genero campo?, si no, continuo
  205.        dibuja el mapa
  206.        xIt e yIt determina la cantidad de cuadras
  207.        el tamaño en pixeles es 10 (primera calle) + 20* cantidad
  208.        de cuadras que estoy recibiendo */
  209.        campo.style.position = "relative";
  210.        
  211.        campo.style.height = (globalSideBlock + ((globalSideBlock*2) * yIt)).toString() + "px";
  212.        campo.yIt = yIt; // cantidad de cuadras verticales
  213.        campo.style.width = (globalSideBlock + ((globalSideBlock*2) * xIt)).toString() + "px";
  214.        campo.xIt = xIt; // cantidad de cuadras horizontales
  215.        campo.style.background = "#000000";
  216.        campo.style.color = "#FFFFFF";
  217.        var x;
  218.        var y = -(globalSideBlock);
  219.        for(var dyIt = 1; dyIt <= yIt; ++dyIt){
  220.          y = y + globalSideBlock*2;
  221.          x = -(globalSideBlock);
  222.          for(var dxIt = 1; dxIt <= xIt; ++ dxIt){
  223.            var miniCaja = drawObjeto(campo,"#FFFCCC");
  224.            x = x + globalSideBlock*2;
  225.            miniCaja.style.left = x.toString() + 'px';
  226.            miniCaja.style.top = y.toString() + 'px';
  227.          }
  228.        }
  229.        // para no volver a dibujar el campo si se lo llama dos veces
  230.        campo.id = "CAMPO";
  231.        return campo;
  232.      } else {
  233.           /*por alguna extraña y misteriosa razon, javascript retorna
  234.           un return aunque este dentro de un if que no se cumpla
  235.           por mas redundante que parezca este else, es la unica
  236.           manera de evitar un error si se llama dos veces la funcion */
  237.           return globalCampo;
  238.           }
  239.      }
  240.     function drawObstaculo(campo){
  241.         /* cantidad de obstaculos entre 1 y 10
  242.          * tipo= 1: solo obstaculos, 2: solo energia, 3: ambos (NOT YET) */
  243.         var cantidad = Math.round(Math.random()*100);
  244.         for(var i = 1; i<=cantidad; ++i){
  245.             var obstaculo = drawObjeto(campo,"#444FFF");
  246.             /* para que no pisen la posicion original del robot
  247.              * se inicia en 10 */
  248.             obstaculo.id = "OBSTACULO";
  249.             obstaculo.style.left = getPosicionAleatoria(globalSideBlock,campo.xIt).toString() + "px";
  250.             obstaculo.style.top = getPosicionAleatoria(globalSideBlock,campo.yIt).toString() + "px";
  251.             }
  252.         return cantidad;
  253.         }
  254.  
  255.    function getPosicionAleatoria(min, max) {
  256.         /* Genera numero de pixel que siempre cae en la esquina de una calle
  257.          * **********************************************************
  258.          * Nos llevamos mal, pero a veces coqueteo con la matematica:
  259.          * N = (((0,aleatorio) * (max-min) + min) / lado) * lado
  260.          * **********************************************************/
  261.         max = ((globalSideBlock*2) * max) // lo transformo a pixeles reales
  262.         var random = Math.round((Math.random() * (max-min) + min) / globalSideBlock) * globalSideBlock;
  263.         if(!(random % (globalSideBlock*2) == 0)) random += globalSideBlock; // sumo Lado px
  264.         return random;
  265.     }
  266.     function drawObjeto(campo,color){
  267.         /* todos los objetos como las cuadras, el robot o los obstculos
  268.          * son iguales, luego si quieren ser transparentes y contener una
  269.          * letra da igual, ESTA PROPIEDAD SE REPITE! */
  270.         var objeto = document.createElement("div");
  271.         objeto.style.background = color;
  272.         objeto.style.width = globalSideBlock.toString() + "px";
  273.         objeto.style.height = globalSideBlock.toString() + "px";
  274.         campo.appendChild(objeto);
  275.         objeto.style.position = "absolute";
  276.         return objeto;
  277.         }
  278.     function getPosition(element) {
  279.         // codigo sacado de // source of this code
  280.         // http://www.kirupa.com/html5/get_element_position_using_javascript.htm
  281.         // author: Kirupa Chinnathambi
  282.         var xPosition = 0;
  283.         var yPosition = 0;
  284.      
  285.         while(element) {
  286.             xPosition += (element.offsetLeft - element.scrollLeft + element.clientLeft);
  287.             yPosition += (element.offsetTop - element.scrollTop + element.clientTop);
  288.             element = element.offsetParent;
  289.             }
  290.         return { x: xPosition, y: yPosition };
  291.         }
  292.        
  293.        
  294.        
  295.     /* FUNCIONES PARA LA INTERPRETACION DEL CODIGO
  296.      * No se puede modificar un string pasado a una funcion por que siempre
  297.      * se pasa por valor, hay que crear una funcion dentro de string para que
  298.      * se permita la utilizacion de la funcion getWord */
  299.     function parseToArray(str){
  300.         /* convierte el str y sus separaciones en espacios y nuevas lineas en
  301.          un arreglo, ¿Se puede hacer un arreglo tipo bag de elementos
  302.          separadores? */
  303.       var ret = []; // El array principal que contiene todos los datos
  304.       var arr = []; // Array con todas las palabras
  305.       var pila = [[],[]]; // Array que contiene las etiquetas
  306.       var i = 0;
  307.       var subI = -1;
  308.       while(i < str.length){
  309.         ++subI;
  310.         arr[subI] = ""; // inicializo en vacio
  311.         while(str[i] == " " ||
  312.               str[i] == "\n"){ ++i; }
  313.         // avanzo i hasta que no haya mas vacios
  314.         while(str[i] != " " &&
  315.               str[i] != "\n" &&
  316.               i < str.length){
  317.           arr[subI] += str[i++];
  318.         }
  319.         if(arr[subI][arr[subI].length - 1] == ":"){
  320.             /* agrego las etiquetas antes que el resto de la interpretacion
  321.             del codigo, de esta manera, puede hacerse interpretacion de
  322.             codigo con saltos hacia etiquetas todavia no declaradas durante
  323.             la interpretacion */
  324.             pila[0].push(arr[subI].substr(0,arr[subI].length - 1));
  325.             // en el 0 pongo el nombre para poder buscar
  326.             pila[1].push(subI);
  327.             // en el 1 pongo la instruccion que debe empezar
  328.         }
  329.       }
  330.       ret[0] = arr;
  331.       ret[1] = pila;
  332.       return ret;
  333.     }
  334.     function interprete(str){
  335.         // SIN TERMINAR
  336.        
  337.         // primero llama a la funcion que parsea el contenido
  338.         var parseo = parseToArray(str);
  339.         var arr = parseo[0];
  340.         // el interprete lo que hace es tomar el arreglo de elementos
  341.         // e ir interpretandolos a medida que van llegando
  342.         var pila = parseo[1];
  343.        // donde se guardan las iteraciones, puntos de llamadas y variables
  344.         var ultOp;
  345.         // valor numerico de la ultima operacion realizada
  346.  
  347.         for(var i = 0; i <= arr.length; ++i){
  348.             switch(arr[i]){
  349.                 case "move":
  350.                 case "MOVE":
  351.                     // mover; mueve al robot
  352.                     moverRobot(globalRobot,1);
  353.                     break;
  354.                 case "orie":
  355.                 case "ORIE":
  356.                     // orientacion; cambia de orientacion
  357.                     cambiarOrientacion(globalRobot);
  358.                     break;
  359.                 case "call":
  360.                 case "CALL":
  361.                     // call; llama a una etiqueta
  362.                     if(++i < arr.length){
  363.                         // compruebo que exista el siguiente elemento
  364.                         i = pila[1][pila[0].indexOf(arr[i])];
  365.                         if (i == -1){ alert("ALERTA: No se encontro la etiqueta " + arr[i]); }  
  366.                         // retorno el numero donde se debe empezar a ejecutar
  367.                     } else { alert("ERROR: CALL precisa de un argumento"); }
  368.                     break;
  369.                 case "nada":
  370.                 case "NADA":
  371.                     // como NOP de ASM, este comando no hace nada
  372.                     break;
  373.                 /* case "goto":
  374.                 case "GOTO":
  375.                     // goto: salta a una instruccion especifica
  376.                     if(++i < arr.length){
  377.                         // compruebo que exista el siguiente elemento
  378.                         i = parseInt(arr[i]);
  379.                         // hago que vaya a la posicion numerica indicada
  380.                     }
  381.                     break; */
  382.                 case "ente":
  383.                 case "ENTE":
  384.                     // entero: genera espacio para un entero POSITIVO
  385.                     if(++i < arr.length){
  386.                         pila[0].push(arr[i].substring(0,arr[i].indexOf(",")));
  387.                         // apilo el nombre de la variable
  388.                         pila[1].push(parseInt(arr[i].substring(arr[i].indexOf(",") + 1)));
  389.                         // apilo el valor de la variable
  390.                         }
  391.                     break;
  392.                 case "char":
  393.                 case "char":
  394.                     // char: genera espacio para un caracter
  395.                     if(++i < arr.length){
  396.                         pila[0].push(arr[i].substring(0,arr[i].indexOf(",")));
  397.                         // apilo el nombre de la variable
  398.                         pila[1].push(arr[i].substring(arr[i].indexOf(",") + 1));
  399.                         // apilo el valor de la variable
  400.                         }
  401.                     break;
  402.                 case "stri":
  403.                 case "STRI":
  404.                     // String: genera espacio para una cadena de caracteres
  405.                     // NO FUNCIONA BIEN
  406.                     if(++i < arr.length){
  407.                         pila[0].push(arr[i].substring(0,arr[i].indexOf(",")));
  408.                         // agrego lo que tenga despues de la coma en esta parte
  409.                         var aux = arr[i].substring(arr[i].indexOf(",") + 1);
  410.                         var fin = 0;
  411.                         while(i < arr.length && !fin){
  412.                             // si no contiene ; lo agrego entero
  413.                             if(arr[++i].indexOf(";") != -1){
  414.                                 // si contiene ; solo agrego lo anterior
  415.                                 aux += " " + arr[i].substring(0,arr[i].indexOf(";"));
  416.                                 fin = 1;
  417.                                 } else {
  418.                                     //alert(arr[i]);
  419.                                     aux += " " + arr[i];
  420.                                     //alert("q " + aux);
  421.                                     }
  422.                             }
  423.                         pila[1].push(aux);
  424.                         //alert(aux);
  425.                         }
  426.                     break;
  427.                 case "decr":
  428.                 case "DECR":
  429.                     // decrementar: decrementa en 1 el valor de la variable entera
  430.                     if(++i < arr.length){
  431.                         pila[1][pila[0].indexOf(arr[i])] -= 1;
  432.                         ultOp = pila[1][pila[0].indexOf(arr[i])];
  433.                     }
  434.                     break;
  435.                 case "incr":
  436.                 case "INCR":
  437.                     // incrementar: incrementa en 1 el valor de la variable entera
  438.                     if(++i < arr.length){
  439.                         pila[1][pila[0].indexOf(arr[i])] += 1;
  440.                         ultOp = pila[1][pila[0].indexOf(arr[i])];
  441.                     }
  442.                     break;
  443.                 case "jnz":
  444.                 case "JNZ":
  445.                     // JumpNoZero: salta si la ultima operacion NO dio cero
  446.                     if(ultOp != 0 && ++i < arr.length){
  447.                         i = pila[1][pila[0].indexOf(arr[i])];
  448.                     }
  449.                     break;
  450.                 case "jz":
  451.                 case "JZ":
  452.                     // JumpZero: salta si la ultima operacion DIO cero
  453.                     if(ultOp == 0 && ++i < arr.length){
  454.                         i = pila[1][pila[0].indexOf(arr[i])];
  455.                     }
  456.                     break;
  457.                 case "jmp":
  458.                 case "JMP":
  459.                     // JUMP: salto incondicional
  460.                     if(++i < arr.length){
  461.                         i = pila[1][pila[0].indexOf(arr[i])];
  462.                     }
  463.                 case "suma":
  464.                 case "SUMA":
  465.                     // suma: suma dos variables y guarda el resultado en el primero
  466.                     if(++i < arr.length){
  467.                         pila[1][pila[0].indexOf(arr[i].substring(0,arr[i].indexOf(",")))] += pila[1][pila[0].indexOf(arr[i].substring(arr[i].indexOf(",")+1))];
  468.                     }
  469.                     break;
  470.                 case "rest":
  471.                 case "REST":
  472.                     // Resta: resta dos variables y guarda el resultado en el primero
  473.                     if(++i < arr.length){
  474.                         pila[1][pila[0].indexOf(arr[i].substring(0,arr[i].indexOf(",")))] -= pila[1][pila[0].indexOf(arr[i].substring(arr[i].indexOf(",")+1))];
  475.                     }
  476.                     break;
  477.                 case "comp":
  478.                 case "COMP":
  479.                     // Comparacion: si las dos variables son iguales, pone en la
  480.                     // variable ultima Operacion el numero cero
  481.                     if(++i < arr.length){
  482.                         if(pila[1][pila[0].indexOf(arr[i].substring(0,arr[i].indexOf(",")))] ==
  483.                         pila[1][pila[0].indexOf(arr[i].substring(arr[i].indexOf(",")+1))]){
  484.                             ultOp = 0;
  485.                         }
  486.                     }
  487.                     break;
  488.                 case "mens":
  489.                 case "MENS":
  490.                     // Mensaje: Mustra el contenido de la variable en un alert
  491.                     if(++i < arr.length){
  492.                         alert(pila[1][pila[0].indexOf(arr[i])]);
  493.                     }
  494.                     break;
  495.                 case "halt":
  496.                 case "HALT":
  497.                     // HALT: interrumpe todas las operaciones y vacia el
  498.                     // array de instrucciones
  499.                     pila = [[],[]];
  500.                     arr = "";
  501.                     alert("fin de instrucciones");
  502.                     break;
  503.                 default:
  504.                     // aqui va todo lo que no es fijo o algun regEx;
  505.                     /*if(arr[i][arr[i].length - 1] == ":"){
  506.                         // llamado para etiqueta, hecho desde el parseo
  507.                         pila[0].push(arr[i].substr(0,arr[i].length - 1));
  508.                         // en el 0 pongo el nombre para poder buscar
  509.                         pila[1].push(i);
  510.                         // en el 1 pongo la instruccion que debe empezar
  511.                     }*/
  512.                     break;
  513.             }
  514.         }
  515.         // retorno el arreglo con caracteres por si lo necesito despues
  516.         return parseo;     
  517.     }
  518.    
  519.    
  520.    
  521.     function main(contenedor){
  522.      // todo lo primero que debe ejecutarse y declararse
  523.      globalCampo = drawCampo(contenedor,20,10);
  524.      globalRobot = drawRobot(contenedor);
  525.      var obstaculos = drawObstaculo(globalCampo);
  526.      }
  527.  </script>
  528. </head>
  529. <body onload="javascript:main(document.getElementById('big'));">
  530.     <div class="content">
  531. <div class="content-columns">
  532.     <div class="content-column-left">
  533.         <textarea id="codigo">
  534.    ente a,-2
  535. f: incr a
  536.    jnz f
  537.    orie
  538.    orie
  539.    move
  540.    halt</textarea>
  541.         <br>
  542.         <input type="button" id="boton" value="parse code" onclick="javascript:globalCom = interprete(document.getElementById('codigo').value);" />
  543.         <input type="button" id="boton" value="cambiar orientacion" onclick="javascript:cambiarOrientacion(globalRobot);" />
  544.         <input type="button" id="boton" value="mover" onclick="javascript:moverRobot(globalRobot,1);" />
  545.         <input type="button" id="boton" value="generar obstaculos" onclick="javascript:drawObstaculo(globalCampo);" />
  546.     </div>
  547.     <div class="content-column-right">
  548.         <div id="big"></div>
  549.     </div>
  550. </div>
  551. </div>
  552.  
  553. Intento de simulador de "bajo nivel" (practicando javascript);<br>
  554. El objetivo (si se terminaba) era poder tener una forma mas visual de <br>
  555. abstraccion a bajo nivel tipo ensamblador controlando un "robot"<br>
  556. (visualizado como el cuadrado con la R adentro) por una "ciudad" <br>
  557. con obstaculos, para ofrecer una alternativa rapida a quien quiera <br>
  558. practicar este tipo de programacion sin tener que interpretar todo un <br>
  559. set de instrucciones y tener que descargar y "romper" varias veces el ensamblador <br>
  560. Se que hay varios sacrilegios en este codigo, pero es de prueba! sepa entender :)
  561. <br><br>
  562. contacto: afperrens@gmail.com
  563.  
  564.  
  565. </body>
  566. </html>
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!