Godot Engine 4 en Debian 12: instalación (I)

Godot Engine es un motor de creación de videojuegos libre y multiplataforma, una gran alternativa a otros privativos que nos imponen condiciones leoninas para su uso y explotación.

Con él se puede hacer juegos profesionales de gran calidad y de hecho hay muchos ya hechos y que podéis encontrar casi por cualquier sitio.

Permite crear juegos en 2D y en 3D.

Si estás pensando crear un videojuego sopesaría usar este motor.

Hay dos versiones, la normal en lenguaje gdscript o una especial en lenguaje .NET para quien está acostumbrado a este lenguaje. En casi todos los sitios se recomienda la normal.

Vale, ¿y como se instala?

Lo mejor es que ni siquiera tienes que instalarlo, al menos en GNU/Linux, basta con descargarte la última versión estable de la página de descargas en una carpeta, darle permisos de ejecución y ejecutarlo con el comando:

./godotengine

Si no se viera bien es porque tu tarjeta gráfica es muy antigua, y no cumples con los requisitos mínimos como es mi caso, se soluciona lanzando el comando con el siguiente parámetro:

./godotengine --single-window 

En el caso de Debian 12 también lo puedes instalar desde los repositorios oficiales, pero tendrás la versión 3, que puede que te interese más por retrocompatibilidad, incluso puedes tener "instaladas" las dos versiones.

Primeros pasos

Lo primero es crear nuestro proyecto al que le pondremos un nombre, en el que hay que elegir las algunas opciones entre las que destaca las  de Renderizador entre las que podemos elegir:

• Forward+: para usar el hardware más moderno y puntero, en mi caso no es la mejor opción y si quieres que el juego funcione con hardware más antiguo tampoco va a ser la tuya.
• Móvil: adecuado para el hardware más limitado de los móviles, aunque el proyecto se pueda luego exportar igual a no vamos a utilizar la potencia del hardware más moderno lo ideal es elegir la opción 'Compatibilidad' en la opción Renderizador.
• Compatibilidad: pensada para la mayor compatibilidad posible y equipos con menos recursos, esta es la que yo voy a usar.
  

Como veis también permite controlar el progreso del proyecto con git, algo completamente recomendable y que nos facilitará después la subida a algún repositorio como gitlab o github por ejemplo.

Una vez que creamos el nuevo proyecto nos aparecerá una vista para crea un proyecto de juego en 3D

Pero para empezar se recomienda iniciarse con la creación de un juego 2D, podemos ir cambiando entre unos y otros haciendo clic en los textos que ahí encima de la zona de desarrollo, pudiendo elegir entre Scripts y Asseslib.

En la opción Accesslib podemos descargar recursos y complementos que podamos necesitar para nuestro proyecto.

Intenta hacer alguna chorrada pequeña solo para familiarte con este software, los vídeos que te dejo al final te ayudarán, ve poco a poco.

Ya lo puedes exportar como un ejecutable portable, para ello abre el proyecto con el que has estado trabajando y ve a las opciones:

Proyecto ► Exportar ► Añadir

La primera vez descargará el paquete para exportar que tardará un poco, y ya puedes elegir el sistema para ejecutar tu juego, tienes disponibles:

• Android
• GNU/Linux (arquitecturas: x86_64, x86_32, arm64, arm32, rv64, ppc64, ppc32)
• MacOS
• Web
  
• Windows (arquitecturas: x86_64, x86_32, arm64).
  

En futuros artículos iremos viendo como hacer algunas cosas con este motor, por ahora aquí tienes algunos sitios para iniciarnos en Godot Engine:

• Cómo usar Godot y Aprender desde CERO a hacer juegos.
  
• Curso GODOT 4 desde CERO.
• Tu primer juego en 2D.
• Cursos de Godot 4 Gratis Para Principiantes.
• Godot 4.3: Crea Tu Primer Juego en 2D desde Cero (Tutorial 2024).
  
• Godot 4.3: Crea Tu Primer Juego en 2D desde Cero (Ejemplos).
• Cómo crear TILEMAPS en Godot (Godot 4.3+). 
• TODOS los NODOS 2D de GODOT explicados en 11 minutos. 
• Referencia al lenguaje GDScript.
  

Estad atentos a esta lista de enlaces porque irá creciendo a medida que vaya descubriendo más. ;-)

Ampliando RetroMultiInstaller: los scripts de instalación (V)

El directorio installers es la carpeta que contiene toda colección de scripts que instalan cada uno de los programas.

Estos scripts se ejecutan desde el script instalador.sh desde la carpeta tmp para que los archivos temporales se creen en esa ruta.

El nombre del archivo del script de instalación que vamos a ejecutar sería la etiqueta que tenemos definida en el correspondiente archivo txt de la carpeta /menu seguido del sufijo _installer.sh
Si lo ejecutamos manualmente para probar que funciona correctamente hay que ir a la carpeta tmp y ejecutarlos así:

../installers/programa_installer.sh

Un ejemplo simple de script de instalación de software podría ser así:

#/bin/bash
../commonscripts/instalator.sh git
../commonscripts/createshortcuts.sh desktopcal
source ../commonscripts/makeopenchangetodir.sh /opt/webapps
git clone https://github.com/hvianna/desktopCal.js desktopcal

Los scripts que están dentro de la carpeta ../commonscripts son scripts para diversos usos que veremos en el próximo epígrafe.
El último de estos script se invoca con la instrucción source al principio, esto se hace para cambiar al directorio indicado. Hay que tener especial cuidado con los scripts que se ejecuten después de él, ya que a partir de ahora ya no se van a ejecutar desde la carpeta tmp sino por la indicada en este último script.
Después de git clone se pueden añadir todos los comandos para compilar el programa, si requiriera compilación, integración, etc…

Ampliando RetroMultiInstaller: el script principal (IV)

retroinstaller.sh es el script principal que debemos ejecutar para lanzar el RetroMultiinstaller, para analizar el código más en profundidad, he incluido en el mismo un comentario con un número que identifica lo explicado en los siguientes puntos:

1. La primera línea es distinta al típico /bin/bash para que también podamos ejecutarlo haciendo doble clic sobre el script en un entorno gráfico.
2. Definimos la función is_missing_dialog_pkg que comprueba si el paquete dialog está instalado y si no es así lo instala.
3. Después de invocar la función para instalar dialog si es preciso entramos en un bucle infinito.
4. Se asigna a la variable “seleccion” la salida del comando menugen.sh, pasada a minúsculas. El script ‘menugen.sh’ es el que realmente dibuja los menús y lo veremos más adelante.
5. Si se elige “exit” o se cancela el menú se sale del menú y se acaba la ejecución.
6. Si existe un archivo en la carpeta menús cuyo nombre sea igual al valor de la variable “seleccion” más la extensión “.txt” se ejecuta de nuevo el script pero pasándole como parámetro el valor de la variable “seleccion”.
7. Si selección toma un valor distinto a “exit” se ejecuta el comando cuyo nombre es el valor de la variable selección seguido de “_installer.sh”.
8. En este caso también se muestra un texto de ayuda con el script warninggen.sh de la carpeta commonscripts, si existe el archivo warning/seleccion.txt 

A continuación podemos ver como quedaría el script:

#!/usr/bin/env bash
function is_missing_dialog_pkg() { #2
    if [ ! -f /usr/bin/dialog ]; then
        while true; do
            read -p "Missing 'dialog' package. Do you wish to let me try to install it for you? (aprox. 1.3 kB) [y/n] " yn
            case $yn in
            [Yy]*)
                ./commonscripts/instalator.sh dialog
                break
                ;;
            [Nn]*)
                echo "Please install 'dialog' package to continue."
                exit 1
                ;;
            *) echo "Please answer (y)es or (n)o." ;;
            esac
        done
    fi
}

#3
is_missing_dialog_pkg
#Blue infinito para pintar los menus #3
while true; do
    #4
    seleccion=$(./commonscripts/menugen.sh $1  | tr '[:upper:]' '[:lower:]')
    #5
    if [ $seleccion == "exit" ] || [ -z "$seleccion" ]; then
        clear
        break
    fi
    #6
    if  [ -f "./menus/${seleccion}.txt" ]; then
        ./retroinstaller.sh $seleccion
    else
        #7
        mkdir tmp
        clear
        echo ">>> Installing ${seleccion}..."
        cd tmp
        ../installers/${seleccion}_installer.sh
        #8
        ../commonscripts/warninggen.sh ${seleccion}
        cd ..
    fi
done

Ampliando RetroMultiInstaller: archivos del directorio principal (III)

En el propio directorio donde hemos copiado Multi-installer tenemos una serie de archivos esenciales para su funcionamiento:

• retroinstaller.sh: es el script principal que tendremos que ejecutar para la ejecución del programa desde el directorio donde hemos copiado el programa, ya sea desde consola con la instrucción ./instalador.sh o haciendo doble clic desde el entorno gráfico de GNU/Linux, en cuyo caso tendremos que seleccionar la opción ‘Ejecutar desde una terminal’.
• README.md: documento escrito en el lenguaje markup para wiki en el que podemos incluir una descripción del programa Multi-installer junto con la relación de programas que se pueden instalar con el script, en cada ítem debería incluirse al menos una descripción de lo que hace, enlace para descargar el programa de su página oficial, arquitecturas soportadas, etc.
• TO_DO.md: documento con las mejoras que se desean incluir en un futuro sin plazo determinado.
  
• logo.png: icono identificativo de la aplicación que se mostrará en la descripción del proyecto si se sube a algún servicio de hospedaje de código gestionado por git, como github o gitlab.
  Se recomienda que sea cuadrado, no muy pesado ni grande, 256x256 pixels es una buena opción.
  
• LICENSE: licencia del programa, GNU GPL 3.
  

En el próximo capítulo veremos como funciona el script retroinstaller.sh en más profundidad.

Ampliando RetroMultiInstaller: carpetas principales (II)

Los próximos primeros viernes de cada mes voy a retomar el análisis de la herramienta que creé para agrupar todos los scripts de instalación que tengo y seleccionarlo con un sencillo menú.

Así cada uno podrá adaptar RetroMultiInstaller a sus necesidades.

Aunque en el anterior artículo ya comenté algo de la estructura interna del programa, en este voy a explicar los directorios esenciales que cuelgan de la carpeta donde descomprimos RMI.

En el directorio donde copiamos Multi-installer hay una serie de directorios que contienen otros directorios y archivos.
La estructura de directorios es la siguiente:

├── commonscripts
├── installers
├── menus
├── shotcuts
│   ├── etc
│   │   └── xdg
│   │       └── menus
│   │           └── applications-merged
│   ├── opt
│   └── usr
│       └── share
│           ├── applications
│           ├── desktop-directories
│           └── pixmaps
└── resources
└── warning
└──tmp

Analizando cada directorio con más detalle:

• commonscripts: aquí se incluyen todos los scripts de uso común y que llamaremos desde otros scripts.
• installers: aquí se incluyen los script de instalación, uno por cada programa.
• menus: son los archivos txt que contienen la definición de los menús.
  Cada archivo tiene la definición de un menú y cada línea de cada menú la definición de un programa a instalar o una categoría que abre un nuevo menú.
• shotcuts: incluye todos los archivos para crear los accesos directos con sus iconos y las categorías especiales para agruparlos.
  Dentro de este directorio hay una estructura de subdirectorios igual que donde se van a copiar los archivos en el sistema operativo.
  
• warning: incluye los archivos de texto con instrucciones u otra información que se mostrará al terminar la instalación del programa.
• tmp: carpeta donde se crearán los archivos temporales para las instalaciones tales como el código fuente antes de compilar e instalar.

Casi todos los scripts se ejecutarán desde esta carpeta, por lo que siempre deberemos referirnos a ellos con una ruta relativa que parte de esta carpeta.
Todos los archivos que contienen las carpetas installers, menus, shotcuts y warning correspondientes a un programa a instalar, contienen al principio de su nombre la etiqueta que identifica ese programa en minúsculas.

Free Basic Compiler: compilar programas Basic en GNU/Linux

Free Basic es un compilador de Basic para GNU/Linux bastante compatible con los clásicos intérpretes Basic de MS-DOS.

Instalación

1. Instalar los paquetes necesarios para que funcione:
   sudo apt install build-essential gcc libncurses5-dev libffi-dev libgl1-mesa-dev libx11-dev libxext-dev libxrender-dev libxrandr-dev libxpm-dev libtinfo5 libgpm-dev
   utilindex="freebasic"
   
2. Descargar la última versión para tu sistema operativo, en nuestro caso GNU/Linux.
3. Descomprimir en una carpeta y entrar en esa carpeta.
   
4. Instalar con el script de instalación que incluye:
   sudo ./install.sh -i
5. Si se desea se puede desinstalar con el comando:
   sudo ./install.sh -r
   

Uso

Para compilar un programa:

fbc programa.bas

En este ejemplo, se generará un binario de nombre 'programa'. 

Por cierto, los binarios generados son más pequeños que los creados por QB64, aunque por contra no tenemos una GUI.

Puedes consultar más las opciones del compilador con el comando:

man fbc

En un futuro artículo veremos como adaptar código de Microsoft Basic, GWBasic, QuickBasic, etc... para ser compilado con FreeBasic.
 

Páginas de interés

• Compiling QuickBASIC's Gorillas on Linux... surprisingly tricky.
   

Ampliando RetroMultiInstaller: estructura interna (I)

RetroMultiInstaller es una colección de scripts que facilitan la instalación de programas en distros GNU/Linux de la familia Debian, éste va a ser el primero de varios artículos en el que vamos a aprender a ampliar esta aplicación para que instale también los programas que necesitemos y que aún no estén incluidos, incluso me podéis sugerir la inclusión de scripts de interés adjuntándolos junto a una descripción en la sección de issues.

El primer paso para conocer una nueva herramienta es saber algo de su estructura interna y eso es lo que vamos a tratar de ver hoy, RetroMultiInstaler está pensado para que podamos ver y entender que hacen los scripts aunque seamos novatos en el uso de los mismos, tratando que el código sea claro y comprensible.

Requisitos preliminares

Para usar RetroMultiInstaler necesitamos dos cosas:

• git para su descarga y mantenimiento.
• Que nuestro usuario esté autorizado en sudoers, es decir, que pueda ejecutar programas como administrador mediante la orden sudo.

También necesitaremos el paquete dialog para que pinte los menús, pero el propio script nos pedirá instalarlo en su primera ejecución si no está presente.

Descarga y actualización

Ya podemos descargar el script con toda su estructura con el comando:

git clone https://gitlab.com/cpcbegin/retromultiinstaller

Si ya lo tenemos descargado podemos actualizarlo a la última versión con el comando:

git pull

La actualización es fundamental antes de cambiar algo en el script.

Estructura interna

Estos son los archivos y carpetas principales que cuelgan de la carpeta que contiene el script

• retroinstaller.sh: script principal con el que ejecutamos la herramienta.
• opt: carpeta donde se generan los archivos y carpetas , todos los scripts se ejecutan desde esta ubicación y por tanto todas las rutas relativas deben componerse como si estuviéramos en este directorio. También es conveniente excluirlo del contol de git
• commonscripts: scripts que se usan en varios sitios.
• installers: contiene los scripts de instalación.
• menus: contiene los archivos con los menús, el principal es main.txt que llama al resto de menús ya que se pueden llamar unos a otros. Cada línea contiene una etiqueta índice un espacio y una descripción, dentro de la descripción puede haber espacios pero deben ser espacios duros.
• resources: diversos recursos incluidos en el script.
• shotcuts: archivos a copiar en la estructura del sistema.
• warning: archivos con texto de aviso al finalizar la instalación.
• README.md: Información sobre el software que se puede instalar.

La etiqueta índice del menú debe coinidir con el prefijo del script de instalación, cuyo nombre será indice_installer.sh

También es conveniente que se use en el nombre del resto de archivos del script para mantener la coherencia y facilitar el mantenimiento.   

Netbeans en GNU/Linux

Netbeans es un software para desarrollar grandes proyectos programados en diversos lenguajes, permite control de versiones, etc...

Está escrito en java, por lo que lo primero que hay que hacer es instalarse la última versión openjdk si aún no la hemos instalado.

sudo apt -y install openjdk-16-jdk

Una vez hecho esto basta con descargarse el script de instalación, descomprimirlo, darle permisos de ejecución y ejecutarlo con permisos normales:

chmod +x ./netbeans.sh
./netbeans.sh

Seguimos los pasos del asistente y al final tendremos netbeans listo para su uso.

 

Instalar Rust en Debian, Ubuntu o Linux Mint

Rust es un lenguaje en auge similar a C++ muy eficiente y soportado por Mozilla.

Dado que es usado por cada vez más proyectos lo vamos a tener que instalar más pronto que tarde para compilar algunos y ya de paso probar hacer alguna cosa nosotros mismos. Veremos que es muy fácil.

Vamos a ver como instalarlo en Ubuntu, Linux Mint u otras distribuciones de la familia, recuerda que también puedes instalarlo en Debian teniendo en cuenta un detallito.

Instalación desde el repositorio

Simplemente indicamos que queremos instalar rust y si acaso algún complemento como cargo, en distros de la familia Debian sería tan simple como esto:

sudo apt -y install rustc cargo

Éste es el método más sencillo y el recomendado en la mayoría de los casos, a no ser que se quiera algo más especial.

Compilarlo desde el código

Este procedimiento es adecuado si necesitamos la última versión, como siempre lo primero instalar las librerías necesarias para la compilación:

sudo apt install curl build-essential gcc make

Descargamos e instalamos el script de instalación:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Comprobamos que funciona y que versión hemos instalado:

rustc --version

Por último activamos el entorno:

source ~/.profile
source ~/.cargo/env

Y ya podemos disfrutar de este lenguaje de programación, hay multitud de tutoriales para aprender su sintaxis al ser un lenguaje muy de moda.

SplitPather: buscar todos los archivos con una extensión a partir de un directorio y copiarlos en otro en subdirectorios sucesivos con sus primeras letras

He creado un nuevo script al que le he puesto de nombre SpitPather para que me copie todos los archivos que tenga con una extensión determinada en el árbol de un determinado directorio a otro directorio donde creará un nuevo árbol cuyo primer nivel será el primer carácter del archivo, el segundo la segunda letra y así sucesivamente hasta el nivel de profundidad que defina.

Y te preguntarás, ¿qué utilidad tiene este script? Pues bastante para quien tiene un aparatito en el que tengas que seleccionar uno entre miles de archivos pequeñitos, esta estructura de directorio te facilita la navegación minimizando el número de veces que hay que darle a los botones.

En mi caso me va a venir de perlas para poder navegar por las imagenes de disco que guarde en el pendrive que tengo enganchada a la gotek de mi Amstrad CPC (archivos dsk).

De hecho, los usuarios de este tipo de artilugios para cargar desde pendrives o memorias en ordenadores de los 80 van a poder sacar partido al script y llenar sus dispositivos con las imágenes correspondientes organizadas de la manera más óptima para la posterior navegación.

También le he metido cierta normalización extra para que no tenga problemas al copiar los archivos en un pendrive con FAT32 sobre todo (todo en minúsculas, guiones bajos por espacios, solo tener en cuenta letras y números para componer los subdirectores).

Un ejemplo: supón el archivo 3D Grand Prix.DSK, se copiaría en la ruta destino en la siguiente subruta si elegimos la profundidad por defecto de 3 niveles:

3/d/g/3d_gran_prix.dsk

Además así evitamos duplicidades si tenemos ese mismo archivo en otra ubicación dentro del directorio orígen o con alguna letra cambiada mayúsculas por minúsculas o viceversa.

Es ideal para emuladores de disquetera, de cartucho o de cassette (cpcduino, tzxduino, tapuino, casduino), etc...

Descarga

Lo podéis descargar aquí y por comodidad le daría permisos de ejecución y lo copiaría en la carpeta /usr/local/bin.

chmod +x splipather

Uso

El nuevo comando de linux splitpather se ejecuta en consola pasándole 2 parámetros obligatorios y otros dos opcionales:

1. Ruta de origen donde empezar la búsqueda de archivos.
2. Ruta de destino donde copiaremos los archivos.
3. Extensión de los archivos, no es sensible a mayúsculas (por defecto es dsk).
4. Nivel de profundidad de los subdirectorios (por defecto es 3).

Si escribis el comando splitpather sin parámetros os informará de como usarlo:

splitpather START_PATH DESTINATION_PATH [EXT] [DEPTH]

Un ejemplo de uso real sería algo así:

splitpather "/media/miPC/MIDISCO/emuladores/amstrad_cpc" "/media/miPC/MIDISCO/emuladores/gotek" dsk 3

Le estamos diciendo que:

• Empiece a buscar los archivos en la ruta:
  /media/miPC/MIDISCO/emuladores/amstrad_cpc
• Que cree la nuestra estructura en la ruta:
  /media/miPC/MIDISCO/emuladores/gotek
• Que solo tenga en cuenta los archivos con extensión 'dsk'.
• Que cree una estructura de directorios a partir de la ruta indicada con un nivel de profundidad 3.
  

La estructura de subdirectorios a partir del directorio de destino quedaría más o menos como en la imagen de la derecha.

 

Mejoras para el futuro

El desarrollo del script no termina aquí, va a seguir mejorando, añadiendo mejoras y puliendo errores.

Por ejemplo, en las últimas revisiones los archivos se guardan siempre en minúsculas evitando duplicidades y que no detecten algunos aparatos extensiones que estén en mayúsculas.

No descarto en un futuro hacer un frontend gráfico.

Si detectáis algún problema ponedlo aquí en los comentarios o en la sección de issues del repositorio.

Script instalador modular de emuladores de Amstrad para GNU/Linux

Con la idea de facilitar la instalación de emuladores en Ubuntu y otras distros "parientes" que suelen usar muchos recién llegados por su facilidad (y expertos que necesitan algo que funcione ya para ayer) he creado este script que nos permite instalar diversos emuladores desde el código fuente de una manera tan sencilla y transparente como un simple menú en el que eliges que vas a instalar.

Para instalarlo puedes descargarlo directamente o si tienes instalado git teclear:

git clone https://github.com/cpcbegin/amstrademulatorsinstaller

Si no has instalado git ya estás tardando.

Su ejecución es también muy simple vas a la carpeta y ejecutas setup.sh, o si prefieres desde consola:

cd amstrademulatorsinstaller
./setup.sh

Selecciona el emulator o herramienta deseado, haz clic en Aceptar y empezará la compilación e instalación, incluyendo los paquetes necesarios sin intervención por tu parte.

Después de un rato se añadirá el emulator a la nueva categoría Emuladores del menú de tu entorno gráfico:

Aunque es una versión alpha, ya te va a permitir instalar los emuladores deseados y algunas utilidades, la lista empieza con los emuladores más actuales y usados, pero es una lista que va a ir aumentando, así como mejoras en el script ya que es un proyecto vivo.

Permite instalarlos también en raspberry pi, aunque la compilación será lógicamente más lenta con la excepción de Retro Virtual Machine que por ahora está para PC con GNU/Linux (eso sí para 32 y 64 bits).

En el resto de casos, al partir del código fuente, los binarios generados estarán adaptados a la arquitectura que tengas y además tendrás la última versión salida del horno de sus desarrolladores.

Si detectáis cualquier error o posible mejora lo podéis poner en los comentarios para futuras versiones.

Herramientas libres para desarrollar juegos en plataformas retro en GNU/Linux (y otros sistemas)

Hace poco vimos una lista de herramientas libres para hacer juegos en GNU/Linux, pero también hay multitud de software para desarrollar en plataformas retro, aquí tienes algunas interesantes:

• CPCTelera, herramienta para compilarte tus propios juegos de Amstrad CPC, en un futuro incluirá la posibilidad de exportarlos a Android como una app más.
• Z88dk: Herramienta para desarrollar software para máquinas diferentes máquinas de 8bits en el PC.
• La Churrera, La Churrera es un framework compuesto por un motor modular programado en C y un conjunto de herramientas para hacer juegos para ZX Spectrum.
• GB Studio, un creador de retroaventuras para gameboy. 
• P65Pas, un pascal que compila para Commodore. 
• ZX Basic: interprete y compilador de Basic al estilo de que tenía el ZX Spectrum, es multiplataforma pues está hecho en python.
• Pasmo: ensamblador cruzado Z80, ya se incluye en los repositorios de algunas distros por defecto.
• SDCC - Small Device C Compiler: compilador de C para diversos micros, incluidos el Z80, para cada sistema hay que buscar algún tutorial para usarlo, por ejemplo, aquí tenéis un ejemplo y un manual para Amstrad CPC y las zx spectrum development tools.
• GrafX2: herramienta para crear gráficos usables en máquinas como el C64 y Oric (*).
• GIMP + cbmplugs: GIMP permite leer y guardar imágenes de C64 con este plugin, aquí tenéis un manual de preparación de la imagen  (*).
• ZEsarUX: este emulador libre para GNU/Linux también permite desarrollo retro, hace tiempo puse una receta de instalación a partir del código fuente.
• DAAD: escritor de aventuras tipo Dinamic, hay que compilarlo para tu sistema.

El retro está de moda y de hecho se están creando más juegos para algunas que en su época comercial, yo les echaría un ojo.

Si conocéis algunas más que sean libres y disponibles para GNU/Linux (y operativas por supuesto) déjanos un comentario.

(*) Se incluye en los repositorios de la mayoría de las distros.

Script para actualización limpia de Ubuntu o derivada

Este script actualiza un sistema basado en Ubuntu, Linux Mint o alguna derivada, sin hacer preguntas ni aumentando el espacio ocupado en disco con más y más paquetes antiguos. Al final te apaga el equipo.

#!/bin/bash
sudo apt-get update
sudo apt-get -y upgrade
sudo apt-get -y autoremove
sudo apt-get -y clean
sudo sync
sudo sync
sudo poweroff

Lo puedes emplear de dos maneras:

• Como script propiamente dicho, lo guardas dentro de un archivo (p.e.: 'actualizador' dentro de la carpeta /usr/bin) al que le das permisos de escritura, bastaría con hacer doble clic sobre el archivo o lanzarlo desde la consola (actualizador).
• Como un solo comando, que consistiría en todas las líneas separadas por puntos y coma.

Para usarlo en Debian, o introducimos nuestro usuario en el grupo sudo o lo ejecutamos como root quitando 'sudo' del inicio de cada línea.

IMPORTANTE:  si se trata de un servidor, lógicamente, NO EJECUTES poweroff

Compilar QB64 en GNU/Linux

QB64 es una nueva reimplementación del legendario lenguaje QuickBasic que lo que nos permitirá ejecutar diversos programas hechos en este lenguaje, además de traer funcionalidades nuevas.

 

  

Eso sí, este compilador tiene algunas diferencias con los Basic clásicos de MS-DOS, por lo que el programa posiblemente requiera de algún retoque menor.

Instalación en GNU/Linux en PC

Para compilarlo en GNU/Linux hay que seguir una serie de pasos.

1. Instalamos g++ si todavía no lo tenemos instalado, ya sea desde la herramienta gráfica de tu distro o desde consola con el comando:
   

   sudo apt-get install g++ libglu1-mesa-dev

2. Nos descargamos la última versión de su página de descargas.
3. La descomprimos en la carpeta que queramos, ya sea desde el explorador gráfico de nuestra distro o desde consola:
   

   tar -xcvf qb64-xxx.tar.gz

4. Nos situamos en la carpeta que se creado después de la descompresión y seguimos haciendo las siguientes operaciones en ella.
5. El código tiene el fallo de que el programador ha creado los archivos en formato DOS así que antes de compilar hay que pasarlo a formato linux con el comando:
   find . -name '*.sh' -exec sed -i "s/\r//g" {} \;
6. La compilación se hace simplemente ejecutando el archivo ./setup_lnx.sh

 

Instalación en raspberry pi (raspbian)

Los mismos pasos solo que antes de ejecutar ./setup_lnx.sh hay que editar el archivo internal/c/common.cpp y añadirle la siguiente línea al principio:

#define QB64_NOT_X86

AVISO: Cuando se ejecuta QB64 o programas compilados con este programa la raspberry el uso de la CPU ronda el 90% o más, lo que puede acarrear calentamientos y daños en la plaquita, sobre todo si no está bien refrigerada.
¡Avisados estáis!
 

Uso

Ya podemos usar el nuevo lenguaje, para ello debemos acceder siempre a esta carpeta y ejecutar  ./qb64
Para ejecutar y compilar programas accedemos la opción de menú Run tal y como hacíamos con el QuickBasic original de DOS.

Yo he compilado con éxito en Ubuntu 16.04 de 64 bits y raspberry pi 2.
¡Ah!, está disponible para GNU/Linux, Windows y Mac.

 

Por cierto, aquí tienes algunos juegos clásicos de Basic adaptados a QB64. 

Instalar y configurar LAMP en Centos 7

La instalación de LAMP en Centos tiene una serie de pasos:

Instalación y preparación del propio Centos

• Para evitarnos problemas nos instalamos Centos 7 Everything ISO.
• Configuramos la red para que se inicie al principio:

Editamos un archivo que se debe llamar algo como /etc/sysconfig/network-scripts/ifcfg-eno16777736 para que tenga un aspecto similar a este (subrayado en verde lo que hay que cambiar):

TYPE=Ethernet
BOOTPROTO=dhcp
DEFROUTE=yes
IPV4_FAILURE_FATAL=no
IPV6INIT=no
IPV6_AUTOCONF=yes
IPV6_DEFROUTE=yes
IPV6_PEERDNS=yes
IPV6_PEERROUTES=yes
IPV6_FAILURE_FATAL=no
NAME=eno16777736
UUID=8bb9564b-95c6-49ee-832d-a76e4063964d
DEVICE=eno16777736
ONBOOT=yes 

PEERDNS=yes 

PEERROUTES=yes

Instalación y configuración de LAMP

• Actualizamos el sistema e instalamos los siguientes paquetes:

su -

yum update

yum upgrade

yum install httpd mysql mariadb-server php php-mysql phpmyadmin -y

• Iniciamos los servicios:

service httpd start
chkconfig httpd on
systemctl start mariadb.service
systemctl enable mariadb.service

• Configuramos el cortafuegos:

iptables -I INPUT -p tcp --dport 80 -j ACCEPT

• Para que el cambio del cortafuegos se quede de forma permanente editamos el archivo /etc/rc.local y añadimos esa línea al final
• Definimos las contraseñas y seguridad en mariadb

mysql_secure_installation

Y ya está, es un poco más difícil que en otras distros pero es bastante seguro y robusto, si tenemos el hardware adecuado se podría utilizar en un entorno de producción.

Fuentes

• Install LAMP Server (Apache, MySQL, PHP) On RHEL, CentOS, Scientific Linux 6.5/6.4
• Instalar moodle en Lubuntu 14.04 32 bis.

Máxima:lenguaje de programación matemático GPL

Máxima es un lenguaje de programación matemático GPL muy usado por los profesionales de esta disciplina científica.

Su instalación es muy sencilla, ya que la mayoría de distribuciones la incluyen en sus repositorios oficiales, pudiéndose instalar gráficamente desde sus centros de software o mediante synaptic.

Si queremos instalarla en debian o ubuntu desde la consola, lo haremos de la misma forma que otros programas

sudo apt-get install maxima

Para aprender a manejarlo recomiendo la documentación oficial del programa.

Instalar CPCtelera en Ubuntu

La CPCtelera es una librería de bajo nivel C que facilita mucho las cosas a quien quiere programar para el Amstrad CPC, ya que permite añadirle diversos elementos y compilar el resultado directamente en un archivo DSK o CDT, imágenes de disco y cinta respectivamente para ejecutar en un emulador o pasar a un medio físico para ejecutar en un Amstrad CPC real.

Instalación en Ubuntu 64 bits

• Nos vamos a nuestro directorio $HOME y nos bajamos la última versión del código fuente tecleando:

git clone https://github.com/lronaldo/cpctelera

• Instalamos todo lo necesario para su instalación:

sudo apt-get install build-essential bison flex libboost1.71-dev libfreeimage-dev wget unzip wine mono-runtime

• Procedemos a la instalación en sí:

cd cpctelera

./setup.sh

Si faltara algún elemento lo dirá en el diagnóstico que hace durante la instalación / compilación.

Uso

Lo mejor es consultar en el manual de la propia CPCtelera o en los vídeos que hay en youtube sobre su funcionamiento.

Otros enlaces de interés

• CPCtelera Reference Manual.
• Dominando Ensamblador Z80 (DEZ80): Mastering Z80 Assembler.
• RetroManiac : La CPCtelera permitirá exportar los juegos a Android.

¿Sigo en raspbian o salto a KODI?

Un detallito que le faltaba a la instalación de KODI sobre raspbian es que al arrancar te preguntara si vas a usar el ordenador como tal o como centro multimedia, es decir, si vas a seguir en raspbian o vas a saltar a KODI, y ya puestos si no digo nada que salte a KODI a los 20 segundos.

Para conseguirlo he creado dos archivos con permisos de ejecución:

/usr/local/bin/kodiquestion

#!/bin/bash
zenity --question \
    --title="KODI o Raspbian" \
    --text "¿Arrancamos KODI?" \
    --timeout=20 \
    --ok-label="Saltar a KODI" \
    --cancel-label="Seguir en RASPBIAN"
if [ 1 -ne $? ]; then
    kodi-standalone
fi

 .config/autostart/kodiquestion.desktop

[Desktop Entry] 
Type=Application
Exec=kodiquestion

Recuerda que hay que darles permisos de ejecución para que funcionen:

sudo chmod +x /usr/local/bin/kodiquestion

sudo chmod +x $HOME/.config/autostart/kodiquestion.desktop

La necesidad de hacer esto puede parecer una tontería pero es muy útil si te llevas el aparatito a otro sitio donde no tienes otra cosa más que el móvil o el mando de la propia tele para controlarlo.

SmallBasic: otro intérprete de Basic para GNU/Linux

SmallBASIC es otro intérprete del lenguaje Basic para GNU/Linux, Windows, android... y varios sistemas más como Raspberry pi.

 

Se instala descargando el paquete correspondiente al sistema deseado y en el caso de Ubuntu dicho archivo se puede abrir para su instalación con gdebi, con el centro de software o instalarlo desde consola:

sudo dpkg -i smallbasic...deb
sudo apt-get install -f

Se suele usar para fines educativos, en la wikipedia hay manuales y abundante material para usar este lenguaje.

También hay ejemplos en la página oficial y  el manual de referencia en línea y su foro son esenciales.

Bluegriffon: editor visual libre de páginas web

Bluegriffon, es un excelente editor visual libre de páginas web, al estilo de DreamWeaver pero multiplataforma y libre.

En el caso de Ubuntu, Debian y derivados, basta con descargarse el paquete deb e instalarlo con sus dependencias:
sudo dpkg bluegriffon-3.0.1.Ubuntu16.04-x86_64.deb
sudo apt-get install -f

¿He dicho que era multiplataforma? Sí, también está disponible para Windows y Mac.