sábado, 26 de diciembre de 2015

Una exquisita selección de ROMs para M.A.M.E

M.A.M.E


Ya seas usuario de GNU/Linux, MAC o Windows, puedes disfrutar del famoso emulador M.A.M.E en todas estas plataformas. Un emulador es un programa que simula un hardware específico (o varios simultaneamente) y te permite utilizar programmas y juegos diseñados para dicho hardware.

Si tienes la consola original, para volcar su BIOS y juegos antiguos que puedas convertir a fichero en forma de ROM, o si posees los originales y los buscas por internet en sitios como

A continuación os dejo la mejor selección de juegos Arcade que haya encontrado nunca, pinchando en este enlace.

He echado de menos varios, como por ejemplo:





 Title Screen
Toki


Tetris
Tetris
https://i.ytimg.com/vi/kE-jzDmt1SI/maxresdefault.jpg
Super Pang
Y por supuesto el mitiquisimo Puzzle and Action, que si elegias la prueba que había que saber símbolos Japoneses perdias 5 duros.

http://www.arcade-museum.com/images/118/1181242154147.png
Puzzle & Action
Espero que os haya traido buenos recuerdos, tan buenos como escuchar el opening del Ultima online, madre mía EA que manera de cargarte franquicias tienes...

viernes, 25 de diciembre de 2015

Guia de scripting bash para GNU/Linux II, USAGE

Hoy voy a explicar los conceptos básicos para hacer un script sofisticado y flexible que permita ordenar el código, permitir que vaya creciendo sin desordenarse, y hacer código reutilizable en futuros scripts.

Para conseguir esto, os explico como usar funciones y como procesar opciones para realizar distintas tareas con un mismo script. El concepto USAGE es básico en scripting, el propio script te dice como utilizarlo gracias a la utilización de opciones al invocarlo.

Todo el código del script lo teneis como snippet en mi repositorio público. Si lo ponemos en un fichero con permisos de ejecución y lo lanzamos obtenemos:
./mySecondScript.sh
------- My second script begins execution...
--------------------------------------------
   Executing command: mySecondScript.sh
   At path: /home/piperoman/work/git/bash
  Evaluation options, number of arguments: 0
  Options:  --
------- My second script end now!
---------------------------------

Lo único que nos indica el script es algo de información básica, su nombre, donde se ejecuta, cuantas opciones introducimos y cuales son. En este caso no hemos metido ninguna. Las opciones o argumentos, se meten añadiendo un espacio en blanco y escribiendo algo. Nuestro script debe estar preparado para interpretar la entrada. Si además puede detectar errores y guiar al usuario, mejor.






Probamos a añadir la opción --help (-h también valdría) y añade algo de información:

./mySecondScript.sh --help
...
--------------------------------------------------
|  This function teach you how this script works
|  Usage:
|  ./mySecondScript.sh
|  -h|--help = Print usage
|  -s|--say = Print echo with message
|  -o|--options = Print all options
|  -a|--author = Print author's name
--------------------------------------------------
...
Interesante, vemos 4 opciones, pero... ¿Cómo funciona? En primer lugar, explicamos las funciones. Podemos definir una función en cualquier parte del script con esta sintaxis: nombre() { código } . Por convenio (propio, vamos que me da la gana) todos los nombres de funciones comenzarán con f_nombre, veamos un ejemplo de este script:
f_display_usage()
{
  echo -e "\n--------------------------------------------------"
 echo "|  This function teach you how this script works"
 echo -e "|  Usage:\n|  $0"  # -e option allow use \n
  echo "|  ${optionHelp} = Print usage"
  echo "|  ${optionSay} = Print echo with message"
  echo "|  ${optionPrintOptions} = Print all options"
  echo "|  ${optionAuthor} = Print author's name"
  echo -e "--------------------------------------------------"
}

Para ejecutar el código contenido en la función, basta con invocarla escribiendo su nombre, en este caso se ejecuta si se introduce la opción help:
-h|--help) f_display_usage ;; # Call function


Debes tener presente que al llamar una función, se puede hacer con argumentos, pero dentro de la función no podrás acceder a los anteriores, se resetean. Por esta razón, en este script se guardan los argumentos al comiendo por si se necesitan más adelante.
args=(${@}) # Arguments
Nargs=(${#})  # Number of arguments
Además, asi podemos manipular datos pasando argumentos a las funciones. Sin llamar a ninguna función, tenemos los argumentos en las variables ${0}, ${1}... Siendo la 0 el nombre del programa, y el resto los argumentos introducidos. Para leerlos utilizaremos un bucle:
while [ "$1" != "" ]
do
  echo "Processing option: ${1}"
  case "$1" in
    # Process option
  esac
  shift;  # Advance
done;
Mientras el primer argumento no sea vacio, los leemos. ¿Cómo puede funcionar? Cada iteración miramos el contenido del argumento 1, al procesarlo, usamos shift, este comando elimina el argumento 1 y corre a la izquierda los restantes, quedando en la posición 1 el 2 hasta el N en la posición N-1. Lo hago así por comodidad.



Para aprender a procesar os enseño 2 ejemplos concretos:
      -h|--help) f_display_usage ;; # Call function
      -s|--say) f_say $2 ; shift ;; # Call function with argument, and discard argument
En el primer caso, pedir ayuda, solo se llama la función que explica como se usa. En el caso de usar la opción de decir, utiliza el siguiente argumento para decirlo (asumiendo que el usuario lo ha introducido bien, printeará lo que haya) y corre una posición extra los argumentos para no usar ese argumento como opción. Este formato de usage permite evaluar todas las opciones que se den al script, aunque no analiza que las opciones extra son lo que espera. Veamoslo:
./mySecondScript.sh -a --say hola
...
Processing option: -a

--------------------------------------------------
  The author is: vgoni
--------------------------------------------------
Processing option: --say

--------------------------------------------------
  I want to say: hola
--------------------------------------------------
...




Como podeis ver, utilizamos la opción a, es decir, author, y la opción say con el texto hola. Si has llegado hasta aquí, espero que te estes preguntando ¿Y como funciona la lectura de las opciones? Magia no es. Efectivamente, he usado un truco que explico ahora. Antes del bucle para procesar las opciones, uso el comando getopt para evaluar las opciones que espero como argumentos del comando y guardo el resultado en la variable options:
options=$(getopt -o hs:ao -l help,say:,author,options -- "${@}")
Lo hago antes de llamar a ninguna función porque sino perderíamos los argumentos, como ya he comentado antes. Tienes más información del comando aquí. Básicamente la opción -o indica las opciones validas de 1 caracter, y la opción -l los nombres completos. Si detrás de alguno está el caracter : significa que usa un argumento. Para las opciones help, say con un argumento, autor y opciones, queda como arriba. Después, invoco la función para evaluar la variable, y eso hace el truco.
f_evaluate_options()
{
  echo "  Evaluation options, number of arguments: ${Nargs}"
  eval set -- ${options}
  echo "  Options: ${options}"
}
Con todo el rollo que he metido, te dejo que revises tu el script completo e intentes comprender como funciona todo, para que veas puedas hacer tus propios scripts molones en el futuro.

jueves, 17 de diciembre de 2015

Animation vs Minecraft

Precioso cortometraje con los clásicos monigotes animados peleones mezclado con elementos de Minecraft, muy recomendable! Me he pasado los 15 minutos que dura pegado al monitor. (Via microsiervos)




Probando el steam controller

Por fin tengo en mi poder el alabado/odiado Steam Controller. Para el que no lo sepa, es un mando desarrollado por Valve, que para mi es lo mejor que ha salido al mercado en mucho tiempo. Innovaron hace más de 10 años con el tema de contenido digital, y ahora siguen haciendolo abriendo el camino de GNU/Linux, juegos y periféricos. Guia oficial para ponerlo en marcha aquí.

Sirve para jugar a juegos y para manejar el escritorio, tanto en Windows como en GNU/Linux. Funciona de forma automática al abrir steam, ya sea conectandolo por USB-microUSB, o con el dongle USB que viene con él al comprarlo. Tuve algún problema de permisos de periféricos en Ubuntu, pero solucionarlo es fácil.

Este es el hardware que viene al comprar el mando:
  • 2 pilas AA no recargables
  • Cable USB/Micro USB, sirve para conectar el mando, sin cargarlo.
  • Dongle USB, sirve para enviar señar por wireless.
  • El mando, sirve para jugar :-D

El mando tiene los siguientes botones:

http://hexus.net/media/uploaded/2014/7/73d69b39-81f9-4f39-aba5-d5b1ab0b744d.jpg

  • LB/RB = Left/Right bumper, detecta pulsación. Gatillo superior (parachoques literalmente).
  • LT/RT = Left/Right trigger, detecta 2 tipos de pulsación, media y completa. Gatillo.
  • LG/RG = Left/Right grip, detecta 65ks valores enteros de pulsación. Gatillo inferior interno. (Agarre literalmente)
  • LP/RP = Left/Right pad, es háptico, es decir, sensible al tacto. Se puede configurar como cruceta, como ratón, etc.
  • Seta analógica con 360 grados o 2PI radiantes de valores.
  • A,B,X,Y = Clásicos botones
  • <,> = Botones equivalentes a los míticos Select y start.
  • Steam button = Botón especial para lanzar Steam en bigpicture, sacar la interfaz de Steam en los juegos, o conectar el mando.
  • Giroscopio, sensor de sensibilidad de la rotación del mando.

Es totalmente programable. Ya sea modificando manualmente el archivo de texto steamdesktop.vdf en el path ~/.steam/controller_base, o entrando en el modo big picture de steam, settings, en el apartado de controller a configurations > Desktop configuration. Si no lo has registrado antes, puedes hacerlo en Settings > configurations > Add / Test siguiendo las instrucciones.

Configuración de los controles:
  • Style of input, permite elegir que tipo de accion utilizará el control. Puede ser un Dpad, un joystick, un ratón... según la elegida las siguientes acciones cambian.
  • Requires click, opción para exigir o no pulsación.
  • Layout, el tipo de interacción.
  • Click Action, que hace si se clica
  • Mode shift button, cambiar comportamiento si se está pulsando otra tecla. No acumulable con distintas teclas.
  • Haptics intensity, sensibilidad al tacto (solo controles táctiles)
  • Dead zone, zona donde se considera 0 y no hay acción
  • y muchas más.... dependerá del tipo de control que le querais asignar, investiga tu mismo.
Mi primera configuración avanzada es esta:



En la imagen se puede ver la configuración avanzada que he puesto. Sirve para manejar varias funcionalidades de Linux y de Firefox.
  • LB/RB = Mueve al escritorio de la izquierda o derecha.
  • LT/RT = Botón derecho e izquierdo del ratón respectivamente, porque soy diestro.
  • LG/RG = Shift mode del LP y de la seta analógica.
  • LP normal = Hace scroll en el navegador o juego.
  • LP Shift con RG. En el navegador, arriba abre nueva pestaña, abajo la cierra, izquierda/derecha mueve a la pestaña de la izquierda y derecha respectivamente.
  • RP normal = Ratón.
  • La seta se emplea para manejar las teclas normales, también mueve el navegador o las carpetas.
  • La seta shift con LG, izquierda y derecha mueven la aplicación actual entre escritorios (Equivale a control + alt + shift), arriba y abajo se mueven entre aplicaciónes del mismo escritorio (Equivale a alt + Tab).
  • A,B,X,Y = A es intro, B es espacio, X es J (siguiente post en tumblr o facebook), Y es J (anterior post)
  • <,> = Botones equivalentes a los míticos Select y start.
  • Steam button = Botón especial para lanzar Steam en bigpicture, sacar la interfaz de Steam en los juegos, o conectar el mando.
  • Giroscopio, sensor de sensibilidad de la rotación del mando.

Si no te parece suficiente complicado, estoy pensando en hacer otra que permita aun más cosas manejando shortcuts de Tumblr, copiar y pegar, teclados virtuales, ya haré otra entrada cuando lo domine y cuadre el uso de shift, o cuando añadan más opciones de shift para cada control. También me gustaría poder usar el teclado virtual de Steam en el escritorio, pero creo que al menos de momento no es posible.

Cosas guays:
  • Completamente configurable en combinaciones de teclas.
  • Los gatillos inferiores tienen sensibilidad.
  • El dongle USB se conecta y a utilizar, alternativamente se puede conectar por cable
  • La sensibilidad del pad para emular el ratón es configurable, con respuesta al tacto, y sorprendentemente útil.
  • La bateria son 2 pilas AA, muy cómodo, son intercambiables y permite usar recargables.
Limitaciones:
  • No se puede usar el shift mode con más de una tecla a cada control. Es decir, si apretando un gatillo modificaciones el comportamiento de la cruceta, con otro gatillo no se puede hacer otro comportamiento.
  • Si lo conectamos por cable, y tenemos pilas dentro, estas NO se recargan. La razón es que si se usan pilas no recargables esto podría estropear el mando, como bien indican en este hilo.
  • Es diferente a todo lo que ha salido anteriormente, te puede hacer tener reparos. Si se le dedica un poco de tiempo ya no se quiere volver atrás.
  • Mi novia piensa que ahora le quiero más al mando que a ella.
Espero que os haya gustado, os tendré al tanto de novedades respecto al mando, si son tan interesantes como su funcionamiento y posibilidades para cualquiera que quiera dedicarle un rato. Por desgracia Steam no me paga por estas cosas jeje, acepto donaciones, si me veis por ahí invitarme a unas bravas o algo. Especiales thanks a la señorita K por conseguirmelo, y a la señorita N por entregarmelo.