Tutorial Terrenos en OpenSim (II)

En este segunda parte de los tutoriales para crear regiones y terrenos para OpenSim (OS), vamos a ver la forma de crear conjuntos de sims, o regiones, para constituir archipiélagos, o continentes, mediante la utilización de terrenos y su asignación automática.
esto es algo importante, el automatismo. OS, como bien sabéis, funciona mediante consola. Existen diversas aplicaciones para manejarlo mediante interfases gráficas, pero ahora no vamos a hablar de ellas, pues su implementación requiere compilación y un conocimiento avanzado de OS. Lo importante es que os deis cuenta de que aparte de introducir manualmente los comandos en la consola, podéis hacer que estos se carguen de forma automática, así pues, la introducción manual de los comandos sirve para al fase de creación de vuestro mundo virtual, pero una vez que ya estáis satisfechos con la forma adquirida por vuestras regiones, basta con crear conjuntos de scripts para que no sólo estas se carguen en el arranque, si no que para hacer un backups de vuestro OS, o implementar otro nuevo, os bastará con tener copia de los xml's, los terrenos y esos scripts y siempre tendréis vuestro OS a salvo.

Sin más preámbulos comencemos. Todas las capturas utilizadas en este tutorial las podéis encontrar en mi álbum de Picasa:Parte II.

Como avatar vamos a utilizar el genérico, por defecto, User Test, password: test, que nos propone OS cuando creamos una región. Tenemos ya la región "default" en las coordenadas 1000/1000, (por cierto he cambiado el terreno que había cargado en el tutorial antrior, para reutilizarlo en este tutorial de otra forma) y queremos crear un pequeño continente constituido por cuatro sims situados entre las coordenadas 1001/1001 y 1002/1002. Os recomiendo utilizar una hoja de cálculo (porfa, no el Excel ;-( , usad OpenOffice), para tener claro donde situar en vuestro grid (standalone, pero grid al tener varios sims), como se ve en la captura.

Como bien sabéis, se pueden crear las regiones manualmente de dos maneras. Bien copiando el archivo xml y consiguiendo las uuid's para cada nueva región, o bien mediante el comando "create-region [name] [filename]". Ambas formas están descritas en la guía publicada en la wiki de "Guías en Español de SL", pero voy a enseñaros otro método, especialmente útil si queréis crear decenas de sims (hasta llenar vuestro disco duro, si queréis).

Este método genera las regiones mediante un script en uno de mis lenguajes de programación favoritos: Python. Como más adelante, tengo intención de publicar algunos tutoriales sobre la utilización de Python ahora en realXtend, y dentro de unos meses en OpenSim, os recomiendo que descarguéis el programa desde su página de descargas. Si usáis Windows, 32 bits, este es el enlace.

A continuación acudimos a esta página de OpenSim, y descargamos el genial "Region Generator" y lo descomprimimos en una carpeta de nuestro escritorio.


Al descomprimir, obtenemos cuatro ficheros: la .dll de la runtime, el fichero compilado Python, con su extensión ".py", y dos ejecutables que actúan directamente sobre los comandos de Windows.

Lo que ahora vamos a hacer, es generar un grid completo de sims, que van a cubrir desde la coordenada 1000/1000, hasta la coordenada 1011/1011, lo cual generará una matriz de 11x11 sims, es decir, que vamos a tener un total de 121 sims. (vale, podrían haber sido 10x10 dando 100, pero me gusta el 121 ;-D ).


Una vez que tengamos instalado Python, si actuamos con el botón derecho sobre el fichero
regionconfig.py, nos aparecerá la opción de editarlo con IDLE, el editor de Python.

Al seleccionar esta opción, al cabo de un rato nos aparecerá primero un mensaje de Python Shell, advirtiendo sobre las interferencias que los firewalls personales pueden ocasionar en la conexión IDLE, el cual cerraremos, y el fichero en modo edición.

He subido el código del fichero a:
http://codepad.org/ev0R8fCf

para que podáis seguir este tutorial sin tener que descargar e instalar Python pero os recomiendo que os animéis a instalarlo.

Si abrís el enlace a codepad (Codepad es el mejor método de compartir código), lo veréis mas claro que en una captura.

Lo significativo de este fichero es que está dividido en partes, concretamente en dos, que comienzan con: # START OF REGION y acaban en # END OF REGION. Cada una de estas zonas se divide en la configuración de la región, la del usuario y la de la red.

Podemos copiar cada sección de código y añadirla en el fichero, para configurarla y tener más regiones.

Bien, vamos a modificar el código para que generar la matriz de 121 sims, más que suficiente por ahora ;-D

Para ello acudimos a la carpeta "regions" de nuestro sim, editamos el archivo "default.xml" y copiamos la uuid de usuario, que es: "00000000-0000-0000-0000-000000000000".

Este es el valor que debemos de poner en # User Configuration. Además indicamos los valores de regionname y los demás valores, eliminando la segunda configuración de región para
"RegionSetTwo", (pero ahí podemos pegar el código para generar otros 100 sims, o 1000), quedando el código tal y como he subido tal y como he subido a codepad aquí: http://codepad.org/tgPbKEWD, así podéis descargarlo, sustituir el fichero original (guardadlo aparte) y probarlo.

He dejado los nombres que, por defecto, pone el código para las regiones, porque aunque "RegionSetOne número.coordenadas" es feísimo, también es cierto que nos indica claramente a que región se refiere, y desde el punto de vista de tutorial es lo ideal. Como es lógico, vosotros podéis personalizarlo desde el código, al editar el fichero, o de forma individual.


Bien, ya sólo queda hacer doble click en "regiongen.exe", veremos que se generan las regiones (el trabajo manual que nos ahorra ¿eh?), y aparecen un fichero .pyc, otro .pkl y una
carpeta nueva, llamada Regions.



Vamos a guardar esta carpeta como algo valioso, de forma fácilmente localizable.

Ahora recordemos que queríamos crear en nuestro OS un archipiélago de cuatro sims, situados en1001/1001;1002/1001;1001/1002;1002, así que simplemente buscamos los .xml con esas coordenadas, los copiamos (son los ficheros 13,14,24 y 25) y los pegamos en la carpeta "Regions" de nuestro OS,
el cual quedará como se ve en la captura.

Tal y como os podéis dar cuenta, de esta forma tenemos un repositorio para

instalar todas las regiones que queramos en nuestro OS.

Si queremos editar de forma individual el nombre de una región o el usuario que puede acceder a ella como
propietario, lo editamos de la forma habitual, abriendo el .xml correspondiente, pero cuidado con dos caracterísiticas poco conocidas de OS:

1º Cuando creamos una región, OS no encuentra los comandos de terreno. Si no lo sabíais esto os puede haber desesperado. Creamos una región, queremos hacerla plana con el comando "terrain fill 32" por ejemplo, o con el terrain "load-tile", y no hace nada. Es un bug de OS y se arregla simplemente reiniciando la consola.

2º No puede haber dos usuarios con la misma UUID. Si estamos usando ahora User Test con "00000000-0000-0000-0000-000000000000", y creamos un Albert Opensim con la misma uuid, no podremos teletransportarnos. Ese es un fallo del visor de Linden, el mismo por el cual nos falla el teletransporte en SL o cuando queremos conectarnos. En el caso de SL se debe a que la región que abandonamos no "libera" nuestra uuid para que la egión a la que llegamos la acepte, y debemos esperar a los reset de los servidores o salir de SL y entrar por otra región distinta. En OS simplemente cambiamos la uuid por otra.

Bien veamos como va nuestro OS.
Si arrancamos el visor podemos ver que a la región que teníamos se han unido estas cuatro nuevas.

Ahora debemos "vestirlas", cargando primero un único terreno que se extienda sobre todas ellas, para tener una isla grande, (o un continente pequeño) y luego cargando a cada una de ellas un terreno diferente, con lo que tendremos cuatro islas .

Primero haremos el proceso de forma manual, y luego que sea automática.

Antes de nada, es importante que sepáis como SL y OS interpretan un terreno, por que podéis tener problemas de alturas si usais el Photoshop. El mapa de un sim se interpreta mediante un heightmap. El heightmap is una matriz ,como si fuera una hoja de cálculo, constituída por 256 filas y 256 columnas, valoradas entre 0 y 255, where 0 es el punto mas bajo (la esquina inferior izquierda, que es la más problemática en un sim en SL), y 255 el punto más alto. Asimismo la altura se interpreta entre 0 y 255. Cuando usamos Photoshop, al editar este fichero, lo importa y exporta como un fichero "raw", es decir, que Photoshop lo convierte en una imagen de grises de 256 x 256 pixels , donde un pixel negro representa el nivel de tierra "0" y el pixel totalmente blanco el nivel de tierra de 255 s. ¡Pero hay otra parte del fichero (otro canal), donde se almacena un factor de escla para convertir esos valores en metros!. Para que ese factor de escala se corresponda con el intérprete de OS, utilizando programas de diseño como L3Dt, funcione bien, hay que hacer ciertos ajustes, pero es mejor usar programas como Backhoe (el mejor, pero sólo paraMac), o Bailiwick, que tienen capacidad de editar los canales raw, cosa que L3DT no hace, con lo cual las islas que generamos con este programa, pueden quedar fácilmente bajo el agua.

Una vez aclarado esto, veamos como asignar terreno a los cuatro sims. En OS se puede hacer de dos formas. Una consiste encargar un terreno a cada sim, y es el sistema que se utiliza para crear archipiélagos, y lo haremos más adelante en este mismo tutorial, y la otra consiste en "extender" un terreno sobre los sims elegidos. Este terreno ha de tener, como mínimo, el mismo tamaño que la superficie de los sims a cubrir, y se ejecuta mediante uno de los pocos comandos de OS que depende de la versión de OS que estéis utilizando.
Se treta del comando "terrain load-tile" que ha cambiado según las versiones de OS y está pésimamente documentado. (de hecho, la documentación completa está fuera delportal de OS, aquí: http://opensimulator.wordpress.com/category/terrain/ )

La estructura del comando es: terrain load-tile pf.ext a1 b1 x0 y0

donde:
p= path donde está el fichero del terreno. Si se encuentra en la propia carpeta donde está Opensim.exe, no se pone nada
f=nombre del fichero.
.ext= la extensión del terreno. Se recomienda utilizar .r32 excepto en los ficheros .raw que generaremos con los métodos que explicaré en la tercera parte de este tutorial.
a1= anchura en TILES del terreno
b1= altura en TILES del terreno (tanto a1 como b1 han de ser iguales o mayores que la superficie a cubrir).
x0/y0= Coordenadas del punto donde queremos que empiece a cubrir el terreno. Normalmente coincidente con las coordenadas del sim inferior izquierdo del conjunto.
Son los valores a1b1 y x0y0 los que varían según la versión de OS que utilicéis, y el portal de Opensim no ayuda nada a aclararlo, todo lo contrario:


Como podéis ver, aqui: http://opensimulator.org/wiki/EspriFAQ dice 512, 512,0,0 en cambio aqui http://opensimulator.org/wiki/Tips dice script terrain load-tile simalpha.r32 2 2 0 0. Bien, la realidad es que en las versiones actuales de OS (yo acabo de bajar el código fuente y compilar la versión 6.0.1 para este tutorial), no se usa "script" delante del comando, y funciona como:

a1 y b1 = Son TILES. cada TILE es igual a un sim de 256x256.
x0,y0 = el valor completo de las coordenadas.

Asi para esta versión de OS y para cubrir esos cuatro sims con un terreno, bajamos desde http://opensimulator.org/wiki/Free_Terrains y bajamos el terreno 2x2-island.raw. Este terreno lo renombramos como 2x2.r32 y para hacer las pruebas de que comando "load-tile" funciona correctamente, lo situamos directamente en la carpeta "bin" donde se encuentra Opensim.exe.

Así pues el comando para nuestro caso sería: "terrain load-tile 2x2.r32 2 2 1001 1001". SIEMPRE DESDE ROOT. Si hacemos change-region no funciona. Eso no se dice que yo sepa en las guias, y puede volvernos locos.

Vemos que OS acepta nuestro comando porque contesta almacenando cada "trozo" de terreno en la Base de datos de Region. Si no lo aceptase, o bien daría un error (con el texto en color rojo) o se lo "tragaría" sin hacer nada. Para verificar la carga de los terrenos acudimos al visor, donde vemos que eltereno ha cargado en las islas y que el minimapa si muestra la carga de los terrenos mientras que el mapa nos miente como siempre.




Ahora no nos olvidemos, para mantener el orden en nuestras carpetas, de cortar y pegar nuestro terreno 2x2.r32 en la carpeta de "terrenos", y comprobar que funcionaría poniendo terrenos/2x2.r32 en el comando. Pasemos al siguiente y último paso de esta parte del tutorial. Vamos a generar un archipiélago mediante la carga de terrenos individualizados en cada uno de los sims y luego veremos como crear el conjunto de scripts de arranque.

Para ello vamos a usar los ficheros de:http://opensimulator.org/wiki/Free_Terrains, concretamente el que ya teníamos: 1x1-island.raw, y FiveISles256x256.png, IslandLots256x256.png, y Stadium2-256x256.png
sobre este conjunto de 4 sims.
Mediante el comando "show regions" verificamos que todas las regiones están funcionando, así como su nombre. Utilizando el comando "change-región nombre", nos posicionamos en la región en que queremos cargar el terreno, (si no lo hacemos, el terreno se cargará en la región en que nos encontramos), y cargamos el terreno mediante el comando "terrain load terrenos/nombrefichero.extensión".
Obtenemos lo que indican las siguientes capturas:

Vemos como nuestro pequeño continente se ha convertido en cuatro sims de estilos diferentes (uno de ellos convertido en un súper estadio), y que el mapa sigue mintiendo, a diferencia del minimapa. Ahora guardamos copia del fichero startup_commands.txt en la carpeta de Scripts con un nombre identificativo, como startup_commands_continente.txt, por ejemplo, y modificamos startup_commands.txt para que diga:

//carga del terreno en la region root
terrain load terrenos\1x1.r32
terrain multiply 0.32
terrain bake

//carga de los terrenos en los cuatro sims
//Region 1001/1001
change-region RegionSetOne13
terrain load 1x1.r32
terrain bake

//Region 1001/1002
change-region RegionSetOne14
terrain load Stadium256x256.png
terrain bake

//Region 1002/1001
change-region RegionSetOne24
terrain load IslandLots256x256.png
terrain bake

//Region 1002/1002
change-region RegionSetOne25
terrain load FiveISles256x256.png
terrain bake

Bien, con esto hemos finalizado la configuración de nuestro OS para que cargue automáticamente los terrenos.

En la siguiente entrega de este tutorial, explicaré algunos de los métodos existentes para crear neustros propios terenos. No explicaré algunos que son especialmente costosos por el software empleado, como ocurre cuando creamos terenos con Bryce, 3dMax Studio o Mojoworld. En mi caso los empleo porque, unas veces por motivos de trabajo y otras por regalos que me han hecho, tengo licencias de todos ellos, ya que desde hace años desarrollo proyectos con estos programas. Por cierto, que podéis aprovechar y desde mi otro dominio: http://sombra.lamatriz.org/ en: http://sombra.lamatriz.org/terraforming/ podéis descargar libremente algunos de mis antiguos trabajos (y tan antiguos, creo que hace como tres años que no he subido nuevos ficheros ;-D ).y uno de los cambios del php del servidor se ha cargado acentos y "ñ" pero ahí está a vuestra disposición. Eso sí, voy a sustituir esta máquina por una nueva y tardaré en hacer la siguiente entrega. Así os dá tiempo a digerir este tocho-post XD.