Programación en Lenguaje Ensamblador

-El Verdadero Lenguaje de las Máquinas-

Juegos en ensamblador

Ya comente que los mejores juegos se programan en ensamblador. Sin embargo, en muchas escuelas de nivel superior una burla comun es obligar a los pobres alumnos que ni siquiera saben como escribir un pixel a hacer un juego en ensamblador. Si algun maestro de programacion llega a leer esto, le pido por favor que tenga piedad con esos pobres jovenes y no les dejen trabajos que saben bien que no seran capaces de entregar, que le copiaran al nerd o ya si la cosa va en serio al menos preparenlos bien para que no tengan que lamearse algun codigo.

Entre los temas mas buscados esta precisamente el de “juegos en ensamblador”, si eres un maldito lamer que quiere lamearse un codigo para pasar una materia y poder graduarte y convertirte en un DBA de 150 kilos no esperes nada de mi a menos que tengas los argumento$ nece$arios. Por otro lado, si eres un programador de videojuegos que quiere aprender a programar en serio y no manejando paquetes ya hechos cuya licencia cuesta 300,000 dolares se bienvenido a mi site.

De hecho, antes de ser expulsado deshonrosamente de la Universidad de mi estado, mis cuates y yo les haciamos ese tipo de programas a los alumnos que estaban por graduarse. De hecho, uno de los mios firmaba sus codigos con la frase “Que tenga un bonito dia” cuando el programa terminaba su ejecucion, asi que ya saben, si usted es un maestro y un programa termina de este modo sabra que sus alumnos son lamers.

Creo que tengo que poner aunque sea fotos para no hacer tan plano este Blog.

noviembre 23, 2008 - Posted by | Uncategorized | ,

26 comentarios »

  1. bueno como puedo ver sabes demasiado y te felicito por tu paguina que esta excelente, y bueno soy estudiante de electronica titulado y estoy terminanado mi carrera de tecnico en redes, te estaras preguntando que porrada este tipo, o a donde quiere llegar con este mensaje la cosa es que mas de alguna ves supongo que te han enviado mensajes como este pidiendo ayuda .. y bueno el tema es el siguiente como yo no se programación consegui que unos amigos me ayuden con el tema ya son 3 programadores y 2 diseñadores todos metidos en esto de forma libre osea que estamos investigando hace tiempo el asunto y organizandonos para llevarlo a cabo
    te cuento de que se trata

    quiero hacer un juego bueno todos o quien no, quiere hacer uno y la cosa es que en esto del assembler por el tema de electronica lo trate de aprender pero depues de investigar averigue que este lenguaje se ocupa para hacer cosas de verdad y si pudieras ayudarme en el tema para poder aprender assembler te lo agradeceria mucho mira el juego es bastante simple es algo de pelea con unos personajes tipos mugen si me preguntas tecnicismos como que motor quiero ocupar o si tengo las librerias pues no …
    y el motor no tengo mucha idea por el momento asi que a eso respondo si pudieras mandarme los link o material como pdf o tutoriales para poder aprender a programar este proyecto te lo agradeceria por que ya vo el asunto de unas aplicaciones de rpg maker , game maker, div studio y otras cosas y herramientas pero no satisfacen mis gustos en cuanto ha sacar el maximo probecho y tener el maximo control de todo te agradeceria la ayua ya que no es un proyecto de fin de año ni de graduacion que este viendo ahora sino que ahora le di el inicio al este y ya este sabaso es la primera junta oficial de grupo :) para cordinarnos con todo … de antemano saludos y gracias

    estupenda pagina …

    Comentario por Abner Caballero | octubre 20, 2009 | Responder

    • en cuanto a las librerias como es un proyecto para hacer un juego parecido a otro en mi caso a SSB super smash bros tengo los sprites de los personajes variados y de varios juegos y musica y sound efect en wav mid y mp3 (como este proyecto no es con fines comerciales ni publicos estoy ocupando este material de los otros juegos por que si no tendria que pagar derechos de autor etc etc etc … si no que va le cambio algo a los sprites y santa solución

      Comentario por Abner Caballero | octubre 20, 2009 | Responder

      • Hay alguien en los foros de discusión del FASM que dijo alguna vez que programar un juego 3D en Ensamblador es como comerse a un elefante, tienes que hacerlo un “Bite”(mordisco) a la vez. En inglés la palabra mordisco es Bite, que suena igual que Byte. Supongo que el mensaje es que hacer un juego 3D en ASM requiere de esfuerzo concienzudo y constante. No es algo que pueda hacerse como pasatiempo solo los fines de semana.

        Supongo que si sabes de electrónica eres consciente del poder del Ensamblador; pero antes de que cometas algún error táctico te recomiendo que leas un par notas de este Blog: “El Circo de Pulgas” que trata de unos aficionados que intentaron hacer una versión propia del Street Fighter y la otra, titulada “Ya Estás Muerto” trata de como muchos de estos proyectos se van por el WC aún antes de que sus desarrolladores se den cuenta de ello. Leelas para evitar cometer los mismos errores.

        En cuanto a tu proyecto ahí te van algunos tips:

        Los formatos gráficos mas sencillos de abrir son el TGA y el PCX, son algo viejos y casi no comprimen pero son infinitamente mas fáciles de manejar que un JPG.

        En cuanto a la música, el formato MP3 es demasiado complicado para un principiante y la mayor parte de la información para manipularlos es restringida. Para efectos de sonido como voces, golpes y explosiones es mejor el WAV. Puedes leerlo directamente. Y para musica no hay como el MIDI. El formato MIDI puede parecer insignificante pero casi no consume recursos, es muy sencillo de leer y te da mucho control sobre la música.

        Si quieres correr tu juego en una PC con Windows no te va a quedar mas remedio que recurrir al DirectX. Pero tranquilo, existe una forma de llamar a DirectX desde Ensamblador y programar con este. No es sencillo pero es posible, espero mas adelante escribir al respecto.

        En cuanto a lo del 3D, estas son palabras mayores. Si lo que quieres es hacer un Super Smash Brothers (ese juego de peleas en 3D con los personajes de Nintendo) vas a necesitar mas que solo saber mover sprites. El hacer un juego en 3 dimensiones involucra muchos conocimientos matemáticos que poco tienen que ver con la programación o la electrónica. Sobre todo algebra lineal, geometría diferencial y cálculo vectorial multivariable. Si realmente quieres iniciarte en la programación de juegos en 3D te recomiendo que intentes primero programar un clon de Star Raiders. Este juego es viejo como un 8088 (de 1979) y con la tecnología de hoy debería de ser muy sencillo hacerlo. Si puedes hacer un clon de Star Raiders en Ensamblador para Windows, además de ganarte mi respeto, tendrás una vaga idea de lo que es la programación de juegos 3D.

        En cuanto a lo de los Engines y las Bibliotecas, yo no soy partidario de su uso. Sobre todo porque ese tipo de cosas no están pensadas para ser usadas desde un lenguaje como Ensamblador y hacerlas funcionar con este requiere un enorme esfuerzo de Ingeniería Inversa por parte del programador. Por lo demás, y si no te vuelves loco y suicidas intentando programar un juego 3D en ensamblador puedes regresar a este Blog para pedir ayuda.

        Por cierto, si quieres puedes contactarme por MSN si quieres ayuda un poco mas directa en eso del juego.

        Comentario por asm86 | octubre 20, 2009

  2. gracias por la pronta respuesta y ya habia leido los articulos mencionados anteriormente y por eso me motive escribirte ya que a mi no me importa el tema de cuanto tiempo tome el asunto o de cuan complejo sea si no que desde siempre he tratado de hacer esto y tengo las ganas y la pasion mas gente que me apoya pero ahora dimos el vamos oficial esta semana para comenzar con todo el proceso que conlleve y este proyecto así como me comentas del 2D y 3D encuentro que para empezar, pensando el 3D no lo haria ni en un millos de años con los conocimientos que tengo para comenzar con el primer juego por ahora, así que para empezar voy a comenzar con uno “simple”, juego en 2D la estructura es bastante basica y organizada
    un juego de pelea con plataformas de peleas en 2D personajes en 2D todo en 2D (en cuanto a las *librerias* que te menciones solo es los sprites por separado no es que tenga un dll o algo asi solo tengo las imagenes de los personajes en otros formatos dentro de ellos jpg, png, y otros similares asi que ahora a pasarlos al formato que me mencionaste y comenzar a trabajarlo)
    te agradesco el haberme aclarado el tema del manejo de imagenes que lo estoy investigando y el formato por lo de el manejo de los sonidos que gracias a eso ya me hago una idea de como manejar mejor el asunto…
    *librerias* carpetas llenas de muchos sriptes, fondos, personajes, musica, efectos de sonidos, logos etc etc todo abierto en jpg, mp3, wav, midi, (zip, rar, estas contienen mas de lo anterior) png etc etc.

    ultima aclaracion lo del supersmash bros existen unos clones en 2D bastante buenos creo pero no hay como lo hecho por uno y los que existen deacarge unos y no me gustaron por que le faltan muchas cosas por que estan hechos por lamers que solo ocuparon unas aplicaciones de copiar pegar o editar pseudo codigo ya establecido y no le dieron el gusto a que buen juego si no que solo una copia barata o hack_facke

    ultimo punto consulte con un amigo que es profesor y ha hecho este tipo de proyectos pero con lenguaje de alto nivel y me facilito las librerias de “direct draw” “directX” y creo que “open GL” y me ofrecio un compilado con dibujos que tiene para este tema….

    Comentario por Abner Caballero | octubre 21, 2009 | Responder

  3. Ultimo comentario entes comenzar

    como tengo de cierta forma mas claro todo pero…
    lo que no se a ciencia cierta es programar en asm
    me gustaria que me mandaras los link o algun tuto full en pdf o de los videos si es que existen para comenzar con el aprendizaje que tiempo tengo bastante y sobre todo por el momento ya que mi trabajo es bastante relajao por ahora y tiempo y dispococion al asunto tengo arta asi que a estudiar y estudiar y meter mano a codigo…. te agradeceria el que me mandaras esa info lo mas completa posibles…. gracias

    Comentario por Abner Caballero | octubre 22, 2009 | Responder

    • Primero que nada necesitas paciencia y constancia. Si no sabes nada de Ensamblador no te desesperes si en un mes o dos no logras entender nada. Llevo algunos dias hilando algunas viejas notas que hablan sobre temas muy elementales sobre como programar en ASM. Si buscas la nota “Ensamblador Desde Cero” ahí encontrarás unos enlaces hacia estas notas. Ahí se explican cosas tan elementales como el sistema binario, lo que son los bits y los bytes, conversiones en binario, hexadecimal y decimal, los registros generales del CPU y el enredado tema del “Direccionamiento” de la memoria. En la misma serie se explican un par de ejemplos incluidos en el FASM. Cuando acabes de ver todo esto estarás en capacidad de entender los Manuales de Intel y cuando los hayas leido te recomiendo los Tutoriales de Iczelion sobre Ensamblador para Windows. De hecho hay en algún lugar de la red un Tetris completo programado en Ensamblador para Windows pero de momento no recuerdo su URL.

      En la barra de la derecha de el blog hay varios enlaces los recursos antes mencionados y otros mas. Te aconsejo que te acostumbres al uso de editores hexadecimales y a debuggers como el OllyDbg, pues la manera mas rápida de aprender a programar en Ensamblador es usar estas herramientas sobre todos los ejemplos ejecutables que encuentres.

      Frase hollywoodesca para acabar:
      Todo lo que necesitas para empezar a programar un juego en Ensamblador puedes encontrarlo en este blog. Pero el Terminar un juego en Ensamblador depende solo de ti.

      Comentario por asm86 | octubre 22, 2009 | Responder

  4. muito Obrigado
    muchas gracias
    tank’s

    Comentario por Abner Caballero | octubre 23, 2009 | Responder

  5. y porque te sacaron de la universidad?

    Comentario por .I. | febrero 23, 2011 | Responder

    • Por ahora solo puedo decirte que mis ideas sobre programacion no eran bien vistas por los desarrolladores mas conservadores. Se manejan muchas teorias sobre el asunto desde que algunos maestros intencionalmente impartian mal sus clases para no perder sus empleos fuera de la universidad hasta simplemente que no aguantaban mi encantadora personalidad. Afortunadamente pude rehacer mi carrera desde cero en otra universidad y aunque le debo a esa segunda almamater la salud mental de mi familia aun asi no miro con buenos ojos que una empresa le de mas importancia a un titulo universitario que a los desarrollos que un programador pueda hacer de manera independiente y cualquiera que actue de esta manera se esta buscando problemas conmigo.

      Respecto a los detalles escabrosos de mi expulsion se cuentan muchas historias que no son del todo falsas, aunque ahora que ya ha pasado casi una decada creo que no “me sacaron” de manera oficial, tan solo restringieron mi libretad de accion por medio de amenazas firmadas, se me quitaron mis derechos como alumno universitario y no pude seguir llevando clases de modo escolarizado. Pero con una gran sonrisa me dijeron que podia continuar mi carrera si no me metia en problemas con nadie, definicion que abarcaba cualquier actividad diferente a presentar examenes y aprobarlos. Pero no, realmente no me expulsaron sino que yo fui quien decidio irse por propia voluntad.

      Siento haberme tardado tanto en contestar pero para mi no es facil hablar sobre este tema.

      Comentario por asm86 | febrero 25, 2011 | Responder

  6. quiero aprender a usar este lenguje,como puedo empesar y donde estan los documentos,tutoriales,guias o loq ue sea que me pueda ayudar a aprender a usa este lenguaje?

    Comentario por armorineSKY | enero 28, 2012 | Responder

    • Empieza por aprender a escribir

      Comentario por barnie | octubre 12, 2012 | Responder

  7. mmm y que tipo de juegos se pueden crear en ensamblador?

    el lenguaje en ensamblador no tiene limites? es decir cualquier tipo de juego puede ser creado?

    Comentario por armorineSKY | febrero 5, 2012 | Responder

  8. hola es interesante, no soy lamer… solo quiero aprender y no encuentro los tutoriales tengo como 2 meses para hacer un juego… :S creo que estoy en problemas

    Comentario por Gelfre | abril 5, 2012 | Responder

    • suponiendo que lo quieras hacer en ensamblador puede que si, en caso de no ser asi intenta descargar cualquier SDK (software developer kit) y estudia los ejemplos. El SDK de directX es gratuito y facil de encontrar. Eso puede ayudarte

      Comentario por asm86 | abril 5, 2012 | Responder

      • bueno gracias almenos me respondieron Xd ggg, ba… assembler tortura para cachinvos… :/ ggg ha ver mas foros.. Xd lo mejor seria un libro ggg

        Comentario por Gelfre | abril 20, 2012

  9. Hola a todos.
    Sé que este tema es de hace bastante, pero al leer la cabecera me he sentido totalmente reflejado. Estoy estudiando Ingerniería Informática, y hemos empezado a ver en la asignatura de “Computadores II” algo de programación en ensamblador, y el procesador motorola 6809.
    Al poco de comenzar a ver este procesador, y sus funciones básicas, nos han mandado crear un programa en ensamblador para el motorola 6809 que consista en una versión simplificada del juego de tanques que avanzan por un campo con minas y deben evitarlas.
    Me cuesta mucho ponerme a ello porque realmente no sé cómo debo hacerlo. He diseñado algunos mapas, y el menú de inicio, pero no sé siquiera cómo tengo que hacer para ejecutar y tener una vista previa de dichos mapas. Si alguien pudiera ayudarme estaría realmente agradecido.

    Añado de forma breve lo solicitado en dicha tarea:

    Se requiere de un programa en ensamblador para el MC6809 que permita jugar a una
    versión simplificada del juego del tanque avanzando por un campo de bombas.
    El juego consiste en:

    • Crear un mapa con el terreno (con las bombas, las paredes y la meta) por
    ejemplo mapa de 20×10.

    • Se deberá controlar la posición del tanque dentro del mapa (en coordenadas X e Y).

    • Mediante la pulsación de unas teclas mover el tanque hacia arriba, abajo,
    derecha e izquierda siempre que en esa posición no haya una pared.

    • El juego termina cuando se realiza un movimiento sobre una bomba, se
    pierde, o cuando se llega a la meta.

    • Es conveniente para mejorar la jugabilidad marcar por donde se ha pasado e
    indicar si hay una bomba en cualquiera de las cuatro posiciones a las que se
    puede mover el tanque.

    El programa, nada más arrancar, mostrará un menú con tres opciones:
    1. Jugar
    2. Instrucciones
    3. Salir
    La opción 1 comenzará el juego. Se jugará hasta perder o ganar y se volverá al
    menú.
    La opción 2 mostrará las instrucciones del juego (teclas para su manejo)
    La opción 3 abandonará el juego.

    Comentario por Smons | abril 8, 2013 | Responder

    • La verdad es que conozco muy poco de los procesadores motorola 68K y aunque los conociera bien necesitaría saber en qué tipo de sistema está corriendo el juego para saber como hacer un código que funcione.

      Pero puede que estos consejos te sirvan

      El mapa es un array de enteros. Si las dimensiones son una potencia de 2 (..8,16, 32, 64,etc) será mejor. En cada valor pones el contenido de lo que sea que haya en el cuadro, por ejemplo 0 es espacio vacio, 1 una mina y 2 es pared. Si tablero tiene lados que sean potencias de 2 puedes convertir la posición x,y del tanque en una dirección lineal dentro del array con OR y desplazamientos binarios. Para leer si puedes o no pisar una posición basta leer que en ella no esté un valor de pared y si el valor es de una mina y te mueves pierdes y ya.

      El menú puedes hacerlo leyendo un número y comprobando o directo desde el teclado. De nuevo no se sobre que sistema trabajes pero todos los menus son un ciclo que se repite hasta que se ingresa un valor. En realidad todo videojuego tiene un ciclo principal llamado Gameloop que permite la interactividad. Quisiera ayudarte mas pero no se en que tipo de sistema estés trabajando

      Comentario por asm86 | abril 8, 2013 | Responder

      • Perdona, es un dato importante y me lo dedé por el camino. En principio estamos programando en linux, en ubuntu 11.04, pero tengo entendido que se valorará que sea compatible con otros OS, con pequeñas variaciones de código. De todas formas, éso es secundario.

        Hmm vale, entonces una vez hecho el array a la hora de jugar todo lo que tengo que hacer es ingresar un bucle que se repita continuamente hasta que el jugador tope con un valor asignado como mina, o llegue a la salida. De todas formas tengo que mirar lo del gameloop e informarme algo más porque no hemos dado nada siquiera similar.

        Una vez que haga las comprobaciones de valores, ¿cómo debo hacer para que en el caso de poder avanzar, ya sea en x o en y, lo haga correctamente? ¿A base de punteros dentro del bucle?

        Muchísimas gracias, ya tengo material para ir trabajando. Te lo agradezco enormemente.

        Comentario por smons | abril 9, 2013

      • Tardé en contestar pero aquí mas consejos.

        Digamos que el mapa es una fila de 5 cuadros (mapa de 5 por 1) y que esos 5 espacios los defines con un array de 5 bytes. Voy a escribirlo en pseudo C porque no me se de memoria los opcodes de los procesadores Motorola

        MAPA;
        mapa[0]=0;
        mapa[1]=0;
        mapa[2]=0;
        mapa[3]=0;
        mapa[4]=3;

        tanque = 0;
        Digamos que un 0 indica terreno despejado, un 1 una pared, un 2 una bomba y un 3 la salida (te recomiendo usar constantes simbólicas para no confundirte). En el ejemplo iniciamos con terreno despejado (puros ceros). Al iniciar el juego tienes que decidir en cual de los cuadros comienza el tanque y que obstáculos habrá en el mapa. La posición del tanque se define con un entero (dos si el mapa es bidimensional y 3 si es en 3D)

        Luego entras a un ciclo en el que le preguntas al usuario si avanza o retrocede, avanzar significa que la variable tanque se incrementa en 1. y retroceder que le restas 1. El valor de la variable tanque es el índice del array. Si por ejemplo iniciaste el tanque en la posición cero y avanzas ahora el tanque está en la posición 1. Revisas lo que hay en mapa[1], si es una pared regresas el tanque a su posición anterior y pones un mensaje que diga que no puedes pasar. Si el contenido de mapa[1] es 2 el juego se termina y si es cero el juego sigue. En pseudocódigo esto sería

        leer movimiento
        tanque_anterior = tanque;
        si movimiento == avanza
        tanque = tanque + 1
        si movimiento = retrocede
        tanque = tanque – 1

        si mapa[tanque] == 0 // territorio libre
        sigue el juego

        si mapa [tanque] == 1 // pared
        no puede pasar, tanque = tanque_anterior

        si mapa [tanque] == 2 // bomba
        fin del juego, perdiste
        ,
        si mapa [tanque] == 3 // salida
        fin del juego, ganaste
        actualizar escena del juego

        La posición tanque_anterior la necesitas para recuperar la posición anterior en caso de moverte hacia una pared. Lo bueno es que puedes hacer este juego con humilde modo texto (consola como lo llaman en linux). También te recomiendo que valides los límites del array para no salirte del mapa. Y que en cada ciclo del gameloop al principio lees el control, luego haces los cálculos y al final dibujas la escena. Espero que con esto puedas hacer tu juego.

        Comentario por asm86 | abril 12, 2013

  10. alguien tiene el juego del snake en radasm, xfis ke me lo pase, lo recompensare lo juro, si lo tienen ponte en contacto con migo, davi_lopez90@hotmail.com xfis me suermega urge

    Comentario por david | junio 3, 2013 | Responder

  11. Hacer programas es una cosa y crear juegos otra de unico modo en que logras hacer algo buwnoes estudiando aunque suene crudo.
    Bueno me resulta un poco raro que uno de los comentarios pregunte como hacerlo que esta en la uni. Yo algo asi y no es por nada pero en k uni estas bn se que haora la informatica ba mal pero buffs jaja.bueno lo que puedo decite es k deves conocer el sistema de recursos saver programar lenguajes maquinas bueno salud

    Comentario por anonimo | junio 5, 2013 | Responder

  12. Esamblador es ilimitado en cuanto muchas cosa cuando desarrollas aplicaciones maquina pero para aplicacionnes multigraficas es una reliquia de la epoca de mi padre,saluds

    Comentario por Saulz | junio 8, 2013 | Responder

  13. hola, slaudos tenai tiempo sin pasar por aqui devido a que mi PC se formateo y perdi la pagina..como sea… en un ultimo intento por encontrar este blog me tope con esto: http://www.lawebdelprogramador.com/foros/Ensamblador/802930-Juego_en_ensamblador.html

    el juego de tres en raya echo en ensambaldor…

    aqui el codigo:

    org 100h

    MAIN:
    mov byte [Paso],0
    mov word [Jug1],0
    mov byte [TxtJugador],”1″
    xor al,al
    mov cx,9
    mov di,C1
    repne stosb

    Datos:
    call Borrar
    mov bx,TxtDatos
    call prtext

    InDatos:
    call input
    cmp al,”1″
    je Principal
    cmp al,”2″
    je PO
    cmp al,”3″
    je OP
    cmp al,”4″
    je OO
    cmp al,”5″
    je OO2
    cmp al,27
    je near Salir
    jmp InDatos

    PO:
    call InputLevel
    mov byte [Jug2],al
    jmp Principal

    OP:
    call InputLevel
    mov byte [Jug1],al
    jmp Principal

    OO2:
    mov byte [Paso],1
    OO:
    mov al,”1″
    call print
    mov al,”.”
    call print
    call InputLevel
    mov byte [Jug1],al
    call prLine
    mov al,”2″
    call print
    mov al,”.”
    call print
    call InputLevel
    mov byte [Jug2],al
    jmp Principal

    InputLevel:
    mov bx,TxtLevel
    call prtext
    mov bl,[MinLevel]
    mov bh,[MaxLevel]

    InputLevelB
    call input
    cmp al,bl
    jb InputLevelB
    cmp al,bh
    jg InputLevelB
    call print
    ret

    Principal:
    call Borrar
    call ImpTablero
    call prLine
    call JJugador
    call Borrar

    Juego:
    call ImpTablero
    call prLine
    call C3R

    call CEmpate
    call IncJugador
    cmp byte [Paso],1
    jne NPaso
    call input
    cmp al,27
    je near WaitEsc
    NPaso
    call JJugador
    call prLine

    call Borrar
    jmp Juego

    JJugador:
    mov bx,TxtTecla
    call PRTEXT
    mov al,[TxtJugador]
    sub al,31h
    xor ah,ah
    mov si,ax
    mov al,[Jug1+si]
    or al,al
    jz near JPersona

    JOrdenador:
    push ax
    call prLine
    pop ax
    cmp al,”1″
    je JOrdenador1
    cmp al,”2″
    je JOrdenador2
    cmp al,”3″
    je JOrdenador3
    cmp al,”4″
    je JOrdenador4

    JOrdenador1:
    mov ax,9
    call Rnd
    mov si,ax
    cmp byte [C1+si],0
    jnz JOrdenador1
    mov al,[TxtJugador]
    sub al,30h
    mov [C1+si],al
    ret

    JOrdenador2:
    call Evitar3
    cmp al,9
    ;mov al,[TxtJugador]
    je JOrdenador1
    xor ah,ah
    mov si,ax
    mov al,[TxtJugador]
    sub al,30h
    mov [C1+si],al
    ret

    JOrdenador3:
    call Ganar3
    cmp al,9
    je JOrdenador2
    xor ah,ah
    mov si,ax
    mov al,[TxtJugador]
    sub al,30h
    mov [C1+si],al
    ret

    JOrdenador4:
    call Ganar3
    cmp al,9
    je CEvitar
    xor ah,ah
    mov si,ax
    mov al,[TxtJugador]
    sub al,30h
    mov [C1+si],al
    ret

    CEvitar:
    call Evitar3
    cmp al,9
    je CCentral
    xor ah,ah
    mov si,ax
    mov al,[TxtJugador]
    sub al,30h
    mov [C1+si],al
    ret

    CCentral:
    cmp byte [C5],0
    jne CBordes
    mov al,[TxtJugador]
    sub al,30h
    mov [C5],al
    mov al,8
    call print
    ret

    CBordes:
    cmp byte [C1],0
    je RBordes
    cmp byte [C3],0
    je RBordes
    cmp byte [C7],0
    je RBordes
    cmp byte [C9],0
    je RBordes
    jmp JOrdenador1

    RBordes:
    mov al,4
    call Rnd
    cmp al,0
    je RBordes1
    cmp al,1
    je RBordes3
    cmp al,2
    je RBordes7
    cmp al,3
    je RBordes9

    RBordes1:
    cmp byte [C1],0
    jne RBordes
    mov al,[TxtJugador]
    sub al,30h
    mov [C1],al
    ret

    RBordes3:
    cmp byte [C3],0
    jne RBordes
    mov al,[TxtJugador]
    sub al,30h
    mov [C3],al
    ret

    RBordes7:
    cmp byte [C7],0
    jne RBordes
    mov al,[TxtJugador]
    sub al,30h
    mov [C7],al
    ret

    RBordes9:
    cmp byte [C9],0
    jne RBordes
    mov al,[TxtJugador]
    sub al,30h
    mov [C9],al
    ret

    Evitar3:
    mov al,[TxtJugador]
    sub al,30h
    add al,1
    cmp al,3
    jne E1
    mov al,1
    jmp E1

    Ganar3:
    mov al,[TxtJugador]
    sub al,30h
    jmp E1

    E1:
    cmp [C1],al
    jne E2

    E12
    cmp [C2],al
    jne E13
    cmp byte [C3],0
    je near RC3

    E13
    cmp [C3],al
    jne E14
    cmp byte [C2],0
    je near RC2

    E14
    cmp [C4],al
    jne E15
    cmp byte [C7],0
    je near RC7

    E15
    cmp [C5],al
    jne E17
    cmp byte [C9],0
    je near RC9

    E17
    cmp [C7],al
    jne E19
    cmp byte [C4],0
    je near RC4

    E19
    cmp [C9],al
    je E2
    cmp byte [C5],0
    je near RC5

    E2:
    cmp [C2],al
    jne E3

    E23
    cmp [C3],al
    jne E25
    cmp byte [C1],0
    je near RC1

    E25:
    cmp [C5],al
    jne E28
    cmp byte [C8],0
    je near RC8

    E28
    cmp [C8],al
    jne E3
    cmp byte [C5],0
    je near RC5

    E3:
    cmp [C3],al
    jne E4

    E35
    cmp [C5],al
    jne E36
    cmp byte [C7],0
    je near RC7

    E36:
    cmp [C6],al
    jne E37
    cmp byte [C9],0
    je near RC9

    E37
    cmp [C7],al
    jne E39
    cmp byte [C5],0
    je near RC5

    E39
    cmp [C9],al
    jne E4
    cmp byte [C6],0
    je near RC6

    E4:
    cmp [C4],al
    jne E5

    E45
    cmp [C5],al
    jne E46
    cmp byte [C6],0
    je near RC6

    E46:
    cmp [C6],al
    jne E47
    cmp byte [C5],0
    je near RC5

    E47:
    cmp [C7],al
    jne E5
    cmp byte [C1],0
    je near RC1

    E5:
    cmp [C5],al
    jne E6

    E56
    cmp [C6],al
    jne E57
    cmp byte [C4],0
    je near RC4

    E57:
    cmp [C7],al
    jne E58
    cmp byte [C3],0
    je near RC3

    E58:
    cmp [C8],al
    jne E59
    cmp byte [C2],0
    je near RC2

    E59:
    cmp [C9],al
    jne E6
    cmp byte [C1],0
    je near RC1

    E6:
    cmp [C6],al
    jne E7

    E69
    cmp [C9],al
    jne E7
    cmp byte [C3],0
    je near RC3

    E7:
    cmp [C7],al
    jne E8

    E78
    cmp [C8],al
    jne E79
    cmp byte [C9],0
    je near RC9

    E79
    cmp [C9],al
    jne E8
    cmp byte [C8],0
    je near RC8

    E8:
    cmp [C8],al
    jne E9

    E89
    cmp [C9],al
    jne E9
    cmp byte [C7],0
    je near RC7

    E9:
    mov al,9
    ret

    RC1:
    mov al,0
    ret
    RC2:
    mov al,1
    ret
    RC3:
    mov al,2
    ret
    RC4:
    mov al,3
    ret
    RC5:
    mov al,4
    ret
    RC6:
    mov al,5
    ret
    RC7:
    mov al,6
    ret
    RC8:
    mov al,7
    ret
    RC9:
    mov al,8
    ret

    JPersona:
    mov al,”,”
    call print
    mov al,” ”
    call print
    mov bx,TxtMover
    call PRTEXT
    call InCasilla
    call prLine
    ret

    Victoria:
    mov bx,TxtVictoria
    mov al,[TxtJugador]
    mov [TxtVic],al
    call prtext
    jmp WaitEsc
    C3R:

    C3R1:
    ;o
    ; o
    ; o
    mov al,[C1]
    or al,al
    jz C3R2
    cmp al,[C5]
    jne C3R2
    cmp al,[C9]
    jne C3R2
    jmp Victoria

    C3R2:
    ; o
    ; o
    ; o
    mov al,[C2]
    or al,al
    jz C3R3
    cmp al,[C5]
    jne C3R3
    cmp al,[C8]
    jne C3R3
    jmp Victoria

    C3R3:
    mov al,[C3]
    or al,al
    jz C3R4
    cmp al,[C5]
    jne C3R4
    cmp al,[C7]
    jne C3R4
    jmp Victoria

    C3R4:
    mov al,[C4]
    or al,al
    jz C3R5
    cmp al,[C5]
    jne C3R5
    cmp al,[C6]
    jne C3R5
    jmp Victoria

    C3R5:
    mov al,[C1]
    or al,al
    jz C3R6
    cmp al,[C2]
    jne C3R6
    cmp al,[C3]
    jne C3R6
    jmp Victoria

    C3R6:
    mov al,[C7]
    or al,al
    jz C3R7
    cmp al,[C8]
    jne C3R7
    cmp al,[C9]
    jne C3R7
    jmp Victoria

    C3R7:
    mov al,[C1]
    or al,al
    jz C3R8
    cmp al,[C4]
    jne C3R8
    cmp al,[C7]
    jne C3R8
    jmp Victoria

    C3R8:
    mov al,[C3]
    or al,al
    jz C3R9
    cmp al,[C6]
    jne C3R9
    cmp al,[C9]
    jne C3R9
    jmp Victoria

    C3R9:
    ret

    CEmpate:
    mov cx,0ah
    mov di,C1
    mov al,0
    repne scasb
    or cx,cx
    jz Empate
    ret

    Empate:
    mov bx,TxtEmpate
    call PRTEXT
    jmp WaitEsc

    IncJugador:
    inc byte [TxtJugador]
    jnp Return
    sub byte [TxtJugador],2
    Return:
    ret

    ImpTablero:
    mov bx,C1
    mov si,0
    mov di,3
    call ImpFila
    call prLine
    mov bx,TxtFil
    call prtext
    mov bx,C1
    mov si,3
    mov di,6
    call ImpFila
    call prLine
    mov bx,TxtFil
    call prtext
    mov bx,C1
    mov si,6
    mov di,9
    call ImpFila
    call prLine
    ret

    ImpFila:
    mov al,[bx+si]
    call ImpCasilla
    inc si
    cmp si,di
    je ImpFilaR
    mov al,”|”
    call print
    jmp ImpFila
    ImpFilaR:
    ret

    InCasilla:
    call input
    cmp al,27
    je MAIN
    cmp al,30h
    jb InCasilla
    cmp al,39h
    ja InCasilla
    xor ah,ah
    mov si,ax
    sub si,31h
    cmp byte [C1+si],0
    jnz InCasilla
    push ax
    mov al,[TxtJugador]
    sub al,30h
    mov [C1+si],al
    pop ax
    call print
    ret

    WaitEsc:
    call input
    cmp al,27
    jne WaitEsc
    jmp MAIN

    Salir:
    call prLine
    jmp 0

    input:
    xor ah,ah
    int 16h
    ret

    ImpCasilla:
    cmp al,1
    je ImpCasillaO
    cmp al,2
    je ImpCasillaX
    mov al,0
    call print
    ret

    ImpCasillaO:
    mov al,”O”
    call print
    ret

    ImpCasillaX
    mov al,”X”
    call print
    ret

    prLine:
    mov al,10
    call print
    mov al,13
    call print
    ret

    print:
    push bx
    push ax
    mov ah,0fh
    int 10h
    pop ax
    mov ah,0eh
    int 10h
    pop bx
    ret

    PRTEXT:
    PUSH AX
    PUSH BX
    PUSH CX
    PUSH DX
    PUSH SI
    MOV SI,0
    CALL PCTEXT
    POP SI
    POP DX
    POP CX
    POP BX
    POP AX
    RET

    PCTEXT:
    MOV AL,[ES:BX+SI]
    CMP AL,0
    JE RETURN
    CALL PRINT
    INC SI
    JMP PCTEXT

    PRINT:
    call print

    RETURN:
    ret

    prtext:
    call PRTEXT
    ret

    Borrar:
    push es
    mov ax,0b800h
    mov es,ax
    mov ah,0fh
    int 10h
    mov ah,2
    xor dx,dx
    int 10h
    mov di,0
    mov cx,1000
    mov ax,720h
    repne stosw
    pop es
    ret

    Rnd:
    mov bl,al
    mov ax,0
    int 1ah
    in al,70h
    and al,128
    out 71h,al
    in al,71h
    mov ax,dx
    xor ah,ah
    div bl
    mov al,ah
    xor ah,ah
    ret

    C1 db 0
    C2 db 0
    C3 db 0
    C4 db 0
    C5 db 0
    C6 db 0
    C7 db 0
    C8 db 0
    C9 db 0
    Jug1 db 0
    Jug2 db 0
    Paso db 0
    TxtFil db “-*-*-“,10,13,0
    TxtTecla db “Turno del jugador ”
    TxtJugador db “1”,0
    TxtMover db “Donde desea mover?”,0
    TxtEmpate db “EMPATE”,0
    TxtVictoria db “VICTORIA JUGADOR ”
    TxtVic db 0,10,13,0
    TxtDatos db “*** 3N LINE 1.0 ***”,10,13,”———————-“,10,13,”ELEGIR TIPO DE JUEGO:”,10,13,”1.Persona-Persona”,10,13,”2.Persona-Ordenador”,10,13,”3.Ordenador-Persona”,10,13,”4.Ordenador-Ordenador”,10,13,”5.Ordenador-Ordenador (Paso a Paso)”,10,13,10,13,”ESC Salir”,10,13,0
    TxtLevel db “Introducir nivel de dificultad (1-2-3-4)”,0
    MinLevel db “1”
    MaxLevel db “4”

    times 800h-($-$$) db 0

    Comentario por armorineSKY | agosto 12, 2013 | Responder

  14. ¿En qué IDE hiciste tu proyecto?

    Comentario por Carlos Juárez | junio 26, 2015 | Responder

    • ¿Cual de todos? Hace mucho usaba el propio IDE del Flatassembler pero de un tiempo aca en lugar de IDE uso Notepad++, Flatassembler en su version de linea de comando y algunos BAT de la consola de Windows. Da mas control sobre el codigo y sobre todo no tarda ni un segundo en compilar.

      Comentario por asm86 | junio 27, 2015 | Responder


Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: