PRESENTACIÓN DEL LENGUAJE ABDLAB-MANCER


Mancer es un lenguaje de nivel medio-alto, procedural y simple. Permite crear códigos complejos para la máquina virtual abdlab turbotron (y estoy trabajando en una versión para (jenova). La estructura interna del mismo tiende a ser minimalista, una órden se compila a muy pocas líneas en turbotronasm (a partir de ahora ttasm) lo que permite además un alto control del lenguaje máquina por parte del programador. Es algo diferente a la mayor parte de lenguajes en varios aspectos, la diferencia más notable es la sintaxis de las ordenes matemáticas ya que estas se deben ejecutar de una en una y el programador indicará en qué bloque de memoria guardará el resultado; Esto es así para evitar que los métodos planeados en el codigo fuente sean muy similares a los del código objeto, Mancer enmascara Ttasm. A pesar de ser ejecutadas de una en una, para facilitar la lectura las órdenes pueden ser apiladas en la misma línea para agrupar cada serie de pasos de una gran operación. Ésta propiedad del lenguaje se usa también en las definiciones de variables, de nuevo por facilidad de lectura se apilan los parámetros tras el nombre de la función.

Otra parte interesante es el interface de entrada-salida (al que llamo de movimientos de datos) que se escribe usando los operadores ">>" (mover desde origen) y "<<" (mover a destino) lo cual simplifica todo bastante al equiparar abstractamente todas las entradas y salidas. Las cadenas de texto se escriben sin usar "", en caso de que el nombre introducido coincida con el nombre de una variable el valor será sustituido por dicho valor (en jenova incluiré un caracter para introducir literales). Los tipos de datos se administran internamente, el usuario no tiene un control directo sobre éstos, pero existen y la máquina los usa.

los tipos son:

var: no es un tipo, indica que se aceptará cualquier tipo de datos. (3, 5.5, cualquier

cosa, incluso esto)

int: número entero de longitud variable. (5, 10500, 7585895)

flo: número de coma flotante, es decir, fraccionado. (1.0, 0.03, 3.1416)

str: cadena de texto, de longitud variable. (A, hola mundo)

Todas las órdenes deben de contener los símbolos "(" y ")" aunque no se utilicen en cierto caso concreto, ya que son los encargados de indicar al intérprete que deben de leer la siguiente órden. Hay dos maneras de introducir un comentario, Un comentario del primer modo será desechado por el intérprete #(str_comentario), es decir, que desaparecerá al ser compilado, el otro modo es la función comentario(str_comentario) que incluirá el comentario en el código ttasm en el lugar correspondiente, puede ser muy útil para etiquetar zonas para su posterior analisis o edición a mano.


Está estructurado en bloques, cada bloque puede contener procedimientos, funciones o código lineal. Un bloque puede siempre llamar a las funciones contenidas en cualquier otro bloque sin restricciones lo cual facilita la reutilización de bloques de funciones (bloque-librería o bloque sin main). La primera línea se usa para indicar el nombre del programa y no se aconseja introducir código en ella.

A grandes rasgos hay 4 tipos de órdenes en Mancer e if:

1- sentencias y movimientos de datos.
2- llamadas y definiciones de funciones o procedimientos
3- tests lógicos
4- operaciones aritméticas y lógicas
5- if

1- sentencias y movimientos de datos:
Sentenciar una variable es darle un valor. En caso de que la variable no exista esta será creada, pero pueden ser creadas con antelación usando la función crear (str_nombre,var_valor). Los movimientos de datos, como he dicho antes, son un interface para simplificar las entradas y las salidas más usadas, hay dos tipos, desde orígenes y hasta destinos. Es como si se tratara de una operación entre dos operadores, el primero es la parte estática y el segundo el valor o parte dinámica, en el modo desde origen la parte estática representa una entrada y la parte dinámica un nombre de variable donde guardar el dato de la estática. En el modo hasta destino la parte estática representa la salida a la que se enviarán los datos del valor. Las partes estáticas disponibles hacen referencia a las entradas o salidas, algunas, como el counter, pueden existir en los dos modos, otros, como la entrada de keypad sólamente sirven para uno de los modos.

 - entradas mover a: estática >> dinámica()

La parte estática puede ser una de las siguientes:

pointer -guarda la posición actual del cabezal lector del programa en la variable indicada.

key -guarda el id de ultima tecla de keypad pulsada en la variable indicada. (NO COMPATIBLE CON JENOVA, usará fakedma *1)

bus -guarda el valor del ultimo dato de hardware recibido en la variable indicada. (NO COMPATIBLE CON JENOVA, usará fakedma)

archivo -guarda todo el texto del archivo indicado (entre paréntesis) en la variable indicada. (REQUISITO EN JENOVA, necesitará periférico *2)

counter -guarda el valor de counter en la variable indicada. (NO COMPATIBLE CON JENOVA, no usa counter)

ejemplos:

pointer >> V_tempP()
archivo >> Todo_El_Texto(str_nombrearchivo)

 - salidas mover de: estática << valor()

chat -envía el valor a la salida de chat (canal indicado en el paréntesis final).

consola -envía el valor a la salida de consola (ftlout).

bus -envía el valor a través del bus indicado entre el paréntesis [ ej. bus << datos(8) ]. (DIFERENCIAS EN JENOVA, el protocolo es diferente *3)

archivo -envía el valor al arvchivo indicado entre el paréntesis [ ej. archivo << texto texto texto fin(file.txt)].

counter -envía el valor (que debe de ser integer) al contador del procesador.

ejemplos:

chat << hola_mundo()
archivo << linea de texto 1 /n linea2 /n linea3()
bus << datos_xxxx(64)

Así pues, si queremos hacer un miniprograma que lea un archivo de texto y lo escriba por el chat haremos lo siguiente:

archivo >> tmp_var1(str_archivo_ejemplo)
chat << tmp_var1()

¿Sencillo, no?, ésta no es la única forma de manejar las entradas o salidas, existen también unas pocas funciones con ese fin, pero esta sintaxis puede simplificar el código muchísimo a la vista del programador.

2- llamadas y definiciones de funciones o procedimientos:
Como en la mayoría de lenguajes mancer incluye una serie de funciones o procedimientos

básicos integrados para la interacción básica con la máquina. Mancer es un lenguaje pequeño, lo que quiere decir que se integran muy pocos procedimientos nativos, pero son más que suficientes para crear comportamientos mucho más complejos.

bloque(str_block): ejecutar el bloque indicado en "str_block"

llamar(str_proc,p1,p2): ejecutar el procedimiento indicado en primer parametro (p1,p2) son opcionales, puede haber cualquier numero de ellos

fin(): finaliza el programa o returna el proceso
_________
usar(str_bib): carga la biblioteca indicada por nombre para poder usar sus funciones (una biblioteca es un código sin funcion main)

#(str_txt): deja un comentario en el programa resultante con el valor indicado en "txt"

variable(str_nombre,var_valor): guardar o crear una variable con el nombre y valor indicados para ser usada posteriormente
_________
escribir(str_texto): escribe en pantalla o consola el texto o variable guardada indicado

chat(str_texto): escribe "str_texto" en el chat

pedir(str_texto,destino): muestra "str_texto" y espera a que el usuario introduzca datos que se guardaran en la variable "destino"
_________
posicion(int_pos): da un nombre a ésta posición para poder volver luego

saltar(int_pos): salta a la posicion indicada en pos y continua el programa desde ahí

las definiciones de procedimientos son una pequeña herramienta para crear tus propias variables y reutilizarlas cuando se quiera, el mecanismo es muy diferente a otros lenguajes, pero el resultado es conceptualmente el mismo. La principal diferencia está en el modo de indicar los parámetros que necesitará nuestro procedimiento. Para declarar un procedimiento sin parámetros se usará la función >(str_nombre_proc) para indicar el final de la misma se usará <(), podremos llamar a dicha función usando call(str_nombre_proc) desde cualquier parte del código. De este modo, si queremos crear un procedimiento con el

código del ejemplo anterior haremos lo siguiente.

>(leer_archivo)
archivo >> tmp_var1(archivo_ejemplo)
chat << tmp_var1()
<()

Y para llamarla símplemente: call(leer_archivo), pero quizas queremos indicar expresamente qué archivo leer en cada momento, para eso necesitaremos añadir parámetros al código, se consigue con el uso de param() o -() (son equivalentes). Entonces, si queremos añadir un parámetro que indique el nombre del archivo a leer el código quedaría así.

>(leer_archivo)-(nA1)
archivo >> tmp_var1(nA1)
chat << tmp_var1()
<()

Y la llamaremos así:

call(leer_archivo,archivo_ejemplo)

podemos añadir cualquier número de parámetros a nuestras funciones y siempre que las llamemos deberemos introducir los valores deseados para estos separados por una coma, igual que en el último ejemplo.

3- tests lógicos:
Los tests lógicos son pequeñas comprobaciones que dan como resultado un sólo bit, hay cuatro de ellos y dos sólo funcionan sobre integer o float. Son sencillos de entender, es como hacer una pregunta simple a la máquina sobre la relación entre dos valores y ésta nos responde con un Si o un No. Para la explicación llamaremos "a" al primer valor y "b" al segundo, aunque en realidad pueden ser cualquier valor o variable. En el paréntesis se indicará el nombre de la variable en la que quedará la respuesta para ser utilizada a posteriori, aquí usaré "bit_check" pero puede ser usado cualquier nombre.

¿es a igual que b? a == b(bit_check)

¿es a distinto que b? a != b(bit_check)

¿es a mayor que b? a > b(bit_check)

¿es a menor que b? a < b(bit_check)


por ejemplo, tras ejecutar esto: 1 > 100(tmp_bit) en tmp_bit tendrémos el valor 0, ya que es falso que 1 sea mayor que 100.

4- operaciones con aritmética y lógica:
Es quizás la parte que menos se parece a otros lenguajes. Mancer ejecuta las operaciones siempre de una en una, y siempre deberemos indicar en el paréntesis dónde quedará la respuesta. Los operadores admitidos hasta ahora son:

aritméticos:
+ sumar
- restar
* multiplicar
/ dividir
& concatenar

lógicos:
AND y boleano
OR o boleano
NOT no boleano

Por ejemplo, si queremos hacer una operación simple cómo 5*5 y guardar el resultado en la variable a_res:

5 * 5(a_res)

Y como las operaciones se pueden apilar y son leidas en orden podemos hacer operaciones más complejas controlando el órden de las mismas,  por ejemplo:

1-5*2-(2+6)=

5 * 2(a_res)1 - a_res(a_res)2 + 6(b_res)a_res - b_res(a_res)

2*pi*r=

2 * pi(a_res)a_res * r(a_res)

(1 and 0) or ((0 and 1) or 1)

0 and 1(a_res)a_res or 1(a_res)1 and 0(b_res)a_res or b_res(a_res)

Es cierto que queda menos legible, pero se tiene control total en el órden de las operaciones y sobre todo en la administración de la memoria temporal. Yo he utilizado el mínimo posible de variables en este ejemplo, pero es posible que se busque guardar los números intermedios con los que se ha llegado hasta el resultado final, por ejemplo si queremos guardar 2*pi y hacer 2*pi*r de una misma vez:

2 * pi(b_res)b_res * r(a_res)

así b_res contiene 2*pi y a_res la operación completa.

5- if
Mancer usa un sistema if minimalista el cual sobre todo simplifica el intérprete (lo siento, programador), if sólo tiene un parámetro que debe de ser un valor boleano, "1" o "0" y no una expresión completa, si se apila tras tests lógicos y operaciones se consigue una funcionalidad igual:

si 3+2 es mayor que "variable" di "OH MY GOD" por el chat:

3 + 2(var1)var1 > variable(var1)if(var1)
chat << OH MY GOD()
end if()

Esta parte puede parecer poco intuitiva, pero con un poco de costumbre se asimila bien, hay que asegurarse siempre de reducir bien la expresión a un sólo bit ya que en caso contrario recibiremos como respuesta siempre 0.

EJEMPLOS DE CÓDIGO MANCER:


chatlogger (guarda todo lo que escucha por el chat en un archivo):

(chatlogger)
 call(escuchar)
>(escuchar)
 posicion(escuchar_more)
 pedir(,tmp001)
 archivo >> tmp002(chat-logs)
 tmp002 & /n(tmp002)tmp002 & tmp001(tmp002)
 archivo << tmp002(chat-logs)
 saltar(escuchar_more)
 <()

propiedades del programa objeto:
1 procedimiento de usuario
35 bloques de memoria (líneas de código maquina)
3512 bits brutos aprox


chatbot simple y escalable para Patxi1 (responde a preguntas simples, no analiza, solo coincidencias exactas)

(stupid chatbot simple)
 pedir(escuchando,msg)
 msg == help(bit)if(bit)
 chat << aqui podria dar ayuda o listar las preguntas aceptadas... mi creador es abderramah()
 asm(goto main)
 end if()
 msg == hola(bit)msg == hola bot(bit1)bit or bit1(bit)if(bit)
 chat << hola!()
 asm(goto main)
 end if()
msg == ¿como te llamas?(bit)msg == ¿cual es tu nombre?(bit1)bit or bit1(bit)if(bit)
 chat << me llamo PATXI I()
 asm(goto main)
 end if()
msg == ¿quien te ha creado?(bit)msg == ¿quien te ha fabricado?(bit1)msg == ¿quien te ha construido?(bit2)bit or bit1(bit)bit or bit2(bit)if(bit)
 chat << mi creador es ABDERRAMAH()
 end if()
msg == ¿que tal?(bit)msg == ¿como estas?(bit1)bit or bit1(bit)if(bit)
 chat << bien, gracias, y tu?()
 asm(goto main)
 end if()
 msg == estoy bien(bit)if(bit)
 chat << me alegro()
 asm(goto main)
 end if()
 asm(goto main)

propiedades del programa objeto:
0 procedimiento de usuario
304 bloques de memoria (líneas de código maquina)
32544 bits brutos aprox

Se puede comprobar que, comparando con el lenguaje lsl, mancer es mucho más corto e
intuitivo (a excepción de las operaciones), ya que se ejecuta sobre una máquina virtual multipropósito no orientada a eventos (como lo es el lenguaje lsl). El código es más lineal en un principio, aunque se puede crear la ilusión de eventos, tan sólo hace falta un poco de estructura. Mancer está diseñado para simplificar la creación de código en turbotron y jenova y en cuanto a eso hace su trabajo muy bien, la abstracción es máxima mientras la diferencia entre un lenguaje y el otro es mínima (mínima dentro de lo que cabe esperar entre un ensamblador y  un lenguaje estructurado de nivel medio-alto). Por otro lado es perfecto para diseñar lenguajes de más alto nivel que en lugar de compilar diréctamente a ttasm utilice mancer como lenguaje intermedio y para cualquier código que use gran número de operaciones (lo cual es muy tedioso en ttasm).



NOTAS:

*- A partir de la versión jenova espero añadir compatiblidad para arrays, en arquitectura turbotron se hacía demasiado complicado.

*- En la versión jenova estoy reestructurando el sistema de movimientos de datos y de entrada y salida de bus.

*- La versión turbotron quedará desmantenida en cuanto jenova sea un hecho.

*- Existe un editor llamado Electromancer que tiene tres versiones, beta, postbeta y godmode. La más completa es godmode, que incluye compatibilidad con el bot patxi1 y con el micro sistema operativo abdlab CCP.

NOTAS 2:

*1- fakedma es el sistema de entrada cacheada activa que permite escuchar en cualquier momento y procesar con "multi", inspirado en la arquitectura dma, aunque no tiene mucho que ver en cuanto a su protocolo y funcionamiento.

*2- jenova necesita un periférico para escribir texto, ya que si no se crearía un requisito especial de permisos no deseado como el de turbotron por usar osfunctions.

*3- mientras que turbotron solo puede enviar una cadena simple de texto a traves de sus buses jenova envía dos simultaneamente, ( bus << datos, datos2(bus) )


ABDLAB SOFTWARE EXPERIMENTAL - 27 dic 2011 - ( abderramah@gmail.com -en
osgrid ABDERRAMAH Scripter )

HAPPY CODE

Buen trabajo Ritchie.

¿Qué permitió el gran trabajo de Dennis Ritchie? ¿Hasta qué punto fue importante su contribución al mundo de la informática? este sencillo esquema nos puede dar una idea de su influencia. 

Dennis MacAlistair Ritchie (September 9, 1941 – October 2011)

Crea un sim en Osgrid en 3 minutos

Se muestra el método más sencillo para crear un sim en osgrid. Dirigido especialmente a gente que no tenga conocimientos sobre el servidor Opensim y su configuración.

De Second life a opensim, desmitificando

Opensim es un software increiblemente versatil y útil, pero está en una fase muy joven de su desarrollo. Si alguna vez has tratado con esta plataforma de realidad virtual seguro te has topado con alguna de sus carencias o alguno de sus bugs. La baja integración con la tecnología de visores 2.0, los fallos en la ejecución de algunos eventos o la pobre implementación de flags de vehiculos son una parte notable de lo que hablo. Cada nueva versión corrige unas cosas, de vez en cuando se abren nuevos fallos y así poco a poco el código va evolucionando. Los que programamos sobre esta plataforma nos acabamos acostumbrando a esto, nos informamos de las funciones implementadas o de como evitar un bug, esto es mejor que usar las alternativas privativas a opensim (si, principalmente hablo de second life).

Tenemos bugs, pero son nuestros bugs, nos pertenecen, pertenecen a la comunidad y no a una empresa privada. Ésto vale más que toda la estabilidad del mundo. Opensim puede ser visto y usado de muchos modos, como programador me gusta verlo como una plataforma online de programación dirigida a objetos en 3d. Un nuevo interface, quizas sea decir mucho, pero es algo parecido a comparar la consola de comandos con el sistema de ventanas y de escritorio. Es un sistema magnifico, ya que permite trabajar en tus programas desde dentro, colaborativamente y a tiempo real y como estamos presenciando los primeros pasos de esta tecnología es un momento muy atractivo para cualquiera que disfrute con la programación, un momento en el que se puede innovar e investigar y en este sentido opensim es muy agradecido.

"Yo uso second life ¿y todos mis amigos?"
Acabarán pasandose, hablales sobre el forzado sistema económico de linden labs. Explicales que second life funciona gracias a una política de la escasez, la cual interfiere con el desarrollo tecnológico libre. Hablales del protocolo hypergrid y de cómo linden labs lo rechaza para proteger su patrimonio económico. Si le gusta construir cuentale que puede crear prims de hasta 512*512, que las islas soportan más de 15000 objetos (en realidad este límite es por culpa del visor), que puedes exportar islas enteras con todos sus prims y scripts para cargarlo cuando y donde quieras. Si le gusta programar hablale de las osfunctions, ninja physics y de el resto de lenguajes soportados (vb, cs, js ...). Si es administrador de terreno cuentale que tendrá sus islas en su propio ordenador, podrá crear el número de ellas que desee y dispondrá de acceso a opciones que en second life solo están disponibles para la plantilla de linden labs. Si es de los que entró a second life empujado por la convicción de que ahí cualquiera se hace rico explicale que eso no funciona así, que ha sido víctima de propaganda vírica y del sensacionalismo. Alguien debe dar el primer salto, al igual que en second life, cuanta más gente seamos más rápido avanzará nuestra tecnología, la diferencia es que en el caso de sl se trata de la tecnología de linden labs, y en el caso de opensim de tecnología de dominio público.

"Configurar y mantener un servidor es muy dificil"
Falso, aunque si es cierto que tiene un tinte de complegidad no se necesitan conocimientos avanzados para poner a funcionar un servidor opensim. Además en cualquiera de los mundos virtuales existentes siempre puedes encontrar gente que estará encantada de echar una mano. Existen versiones especialmente simplificadas como "diva distro" y otras preconfiguradas para descargar y conectar como la de "osgrid".

"Si no viene mi inventario conmigo no me voy a opensim"
Bueno, seras capaz de importar todos los objetos de los que seas el creador. Si compraste algo a alguien casi seguro que no. Aquí solo existe un responsable y es linden labs y su política reacia al protocolo hypergrid, en caso de no existir esta actitud no solo podrías pasar todo tu inventario a entornos opensim, sino que también serías capaz de llevarte cosas de opensim de vuelta a second life. Secondlife no contempla tu derecho a poseer, de manera propiamente dicha, nada que no haya sido construido por ti, es como un alquiler condicional "es tuyo si usas mi plataforma".

"Odio que me bombardeen con propaganda y eventos vacíos de contenido real"
Perfecto, entonces este es tu sitio. Opensim tiene un increíble equilibrio económico por el simple hecho de no generar más gasto que el mantenimiento de los aparatos y las conexiones. Ésto hace que la gente "no te quiera sacar el dinero" constantemente. La gente se dedica a lo que le gusta, los eventos tienen un porqué y un sentido. El terreno es gratuito por lo que no encuentras lugares abarrotados de prims con vendedores de objetos apilados uno encima de otro. Los espacios son amplios, límpios y agradables.

"No quiero administrar mi sim, prefiero tener un terreno alquilado"
También es posible, todo es cuestión de dar con la persona adecuada. Muchos administradores disponen de más terreno del que usan y alquilan parcelas o sims por cantidades ridículas si comparamos con las de second life. Algunas grids ofrecen espacios publicos donde se puede construir o compartir tus creaciones con la comunidad.

"Pero en second life he creado muchas cosas, me da pereza volver a empezar"
Te sorprenderás de lo rápido que eres capaz de crear cuando nada requiere de dinero, cuando sólo te dedicas a lo que te gusta y te olvidas de rentabilizar. Te sorprenderas por las increibles cosas que se pueden hacer de manera gratuita, y de lo fácil que es conseguir creaciones de terceros de gran calidad. Second life ralentiza tanto el ritmo de producción creativa como el de desarrollo tecnológico con su desconcertante política económica.

"Pero yo no se por donde empezar"
Bien, es más fácil de lo que piensas. Opensim es mucho más plural que second life, donde todo se mezcla dando lugar a una masa gris. Existe la posibilidad de crear un servidor de manera local, por lo que sólamente tu ordenador sería capaz de acceder (standalone), pero también hay varios protocolos de conexión, principalmente que te suene grid e hypergrid. En protocolo grid podrías unirte a alguna red existente, algo parecido a conectar tus terrenos a un entorno como second life. Existen otras redes tipo grid que son privadas, las cuales pueden pertenecer a un particular, ya sea un usuario ocasional, una comunidad o una universidad. Lo interesante es que gracias al protocolo hypergrid se puede saltar entre estos diferentes mundos, llevando a tu avatar contigo. Esto crea un gigantesco multiverso interconectado y libre. Para empezar puedes ojear algo de información sobre el servidor y su configuración, si quieres unirte a una gran grid puedes empezar mirando osgrid.org, si buscas gente de habla hispana tienes desarrolloactivo.net o accediendo al foro de hispagrid.com donde puedes consultar dudas o información sobre varias tecnologías referentes al metaverso.

Funciones útiles lsl

1- comparar listas, devolver las coincidencias

// devuelve una lista que contiene solo los objetos contenidos en las dos listas de entrada a la vez

list listmatch( list inputs,list keys ){
list rete=[];
integer point=0;
integer max=llGetListLength( input ) - 1;
while( max >= point ) {
if(llListFindList(keys,llList2String(inputs,point)) != -1){
rete+=llList2String(inputs,point);
}
point+=1;
}
return rete;
}

2- detectar posición desde uuid (sin sensor)

// fuck the sensor hack por abderramah

// 

// detectar posición del agente a través de llGetObjectDetails

// no depende de ningún evento y devuelve la constante ZERO_VECTOR 

// si no detecta nada. (es muy util combinarlo con "distancia entre vectores.txt")

vector scal_getpos(key jedy_obje_t){if (jedy_obje_t){list tmp_vector_lis=llGetObjectDetails(jedy_obje_t, [OBJECT_POS]);

if (tmp_vector_lis!= []){ vector safe_detectedpos= llList2Vector(tmp_vector_lis, 0);return safe_detectedpos;}}return ZERO_VECTOR;

}

3- calcular la distancia entre dos vectores

// por abderramah

// devuelve la distancia entre dos vectores (dme y dhim) en unidades espaciales

float scal_getdist(vector dme, vector dhim){

vector dist=dme-dhim;

float zA;float yA;float xA;float retA;

xA=dist.x;zA=dist.z;yA=dist.y;

if (xA<0){xA=dist.x*-1;} if (yA<0){yA=dist.y*-1;} if (zA<0){zA=dist.z*-1;}

retA=xA+yA+zA;return retA;

}

4- constructor de slurl

// SLURL Maker 0.4 by Dyne Talamasca

// crea un vínculo slurl de la posición actual del prim

slurlmaker(){

vector Where;

string Name;

string SLURL;

vector V;

Name = llGetRegionName();

Where = llGetPos();

V.x = (integer)Where.x;

V.y = (integer)Where.y;

V.z = (integer)Where.z;

// I don't replace any spaces in Name with %20 and so forth.

SLURL = "http://slurl.com/secondlife/" + Name + "/" + (string)V.x + "/" + (string)V.y + "/" + (string)V.z + "/?title=" + Name;

return SLURL;

}

5- tirada de dados

// emula una tirada de dados del número de caras definido en parámetro

// si el número es menor de 1 tira uno de dos caras

integer d(integer caras){

 if(caras>=1){

  return llRound(llFrand(caras - 1)+1);

 }else{

  return llRound(llFrand(2 - 1)+1);

 }

}

El trabajo continúa (Opensim Action Rpg gaming system)

Action rpg es el sistema de combate para opensim que estoy creando con el apoyo de la gente de DaGrid. El juego es ya funcional excepto por el sistema de habilidades, el cual está en desarrollo aún. Estoy trabajando muy duro para llevar éste sistema más allá de lo que cualquier otro similar haya llegado, clases editables sin límite, armas configurables, sistema de compra de items (dinero ficticio) integrado, múltiples habilidades también editables, diferentes modos de juego (los cuales incluyen comportamientos como teleportes dinámicos, mensajes y puntos especiales, sistema de equipos). Como ya comenté en el blog de DaGrid ( desarrolloactivo.com ).

En varios detalles de dicho sistema de juego no tenemos referencias disponibles, así que se deberá diseñar con cuidado. El sistema de edición de armas es uno de ellos, ya que, no se trata de decir al arma cuánto daño debe hacer, sino cuales son las habilidades necesarias para usarla, de este modo no hay armas mejores ni peores, hay armas más o menos apropiadas para tu avatar. Serán editables a partir de notas, así que cualquiera podrá diseñar sus armas únicas y jugar legalmente con ellas o redistribuirlas. Otro tema complicado es la compatibilidad entre juegos del mismo sistema, me explico. Lo que estamos creando no es un simple sistema de juego con unas pocas clases y listo, es un sistema con el cual se podrán desarrollar diferentes entornos de juego, adaptados a diferentes modelos y ambientaciones. En un principio, como prueba incial crearemos Tron ActionRPG (estamos trabajando ya muy duro en el escenario con Sindestino). Pero ésto no significa que ahí acabe la cosa, con el tiempo surgirán juegos medievales, fantásticos, cyberpunk, cybergoth, scifi o incluso realistas, a modo de simulación de tácticas de

combate. El dilema viene en cuanto a que éstos juegos serán compatibles entre si. Podrás ir a tron y jugar como un "programa isomorfico" y luego teleportarte a naboo donde mantendrás tu experiencia y serás, por ejemplo, "Jedi". Podrás conseguir experiencia indistintamente en cualquiera de los entornos y todos tus avances contaran.

Otros códigos anteriores me están siendo de gran utilidad. Turbotron, con un par de modificaciones y un par de programas se ha transformado en una herramienta de administración y pruebas perfecta para el juego y tenemos pensado usar la potencia de Patxi1 (bot con procesador virtual turbotron) para crear npcs controlados por programas escritos en tronasm. Las ideas surgen solas cuando se tiene entre manos algo tan versátil y completo como es este código, y como el título dice, el trabajo continúa. Espero pasar en breve a la fase de pruebas en la que se terminará el desarrollo de los items y habilidades.

Lo prometido es deuda

Electromancer developer queda disponible para su descarga. Es un editor de código simple y a su vez cercano al usuario, contiene descripciones y ayudas así como un detector de errores (que es muy beta, no siempre funciona).

ide principal

ventana de salida del compilador

El lenguaje es muy básico, pero incluyo cuatro librerías de funciones agregables que complementan las carencias y también un sistema externo de ayuda organizado por notas editables [abdlab pirates help], libre y redistribuible (próximamente liberaré el código, es muy simple en realidad, pero cumple bien su trabajo) con entradas de ayuda (por ahora sólo una introducción y algún tema suelto)

sistema de ayuda

Quería terminar Trone, el emulador de turbotron para windows, para incluirlo en el kit, pero por ahora habrá que usar el del mundo virtual ya que tengo problemas puntuales para terminarlo... a su tiempo.

Bueno, éste ha sido mi regalito navideño para todos, hala, que os den :P

descarga: Electromancer postbeta 0.8

Adiós a las caídas, resucita tu server con "COLAFENIX"

Colafénix es un pequeño programa escrito en vb.net que supervisa cada poco tiempo el proceso Opensim.exe, y en caso de no existir reabre el programa. Sirve para esas veces que un error inesperado cierra tu server, y no hay nadie cerca para abrirlo. Es una pena que en ocasiones el programa servidor se queda bloqueado, pero sigue en ejecución, en estos casos colafenix no puede detectar el fallo, sólo actúa ante cierres del proceso.

Link:         http://www.zshare.net/download/83862975f2ab2222/

Alt Link:    http://www.zshare.net/download/838626904f744172/

Tan solo descarga el programa y copialo dentro de la carpeta bin, junto a OpenSim.exe, y ejecuta colafenix.exe, éste abrirá automáticamente el servidor y en caso de cierre inesperado lo reiniciará.

"Electromancer", el SDK para Turbotron

Siguiendo una línea lógica, el proyecto TurboTron pasa por una serie de fases de diseño que dan soporte a otras más complejas y abstractas que facilitan el trabajo del programador. El lenguaje ensamblador, incluyendo la versión actualizada es una herramienta compleja con la que cuesta trabajar, por lo que he comenzado a crear un IDE para windows compatible con un lenguaje procedural de medio-alto nivel que se compila a código nativo TurboTronASM. Aun no está finalizado, pero todo va a la perfección, proximamente estará disponible.

El lenguaje se llama Mancer, no es tipado (por ahora) y abusa de las memorias caché del cpu más de lo que me gustaría (por ahora). Pero a favor suya tiene la simplicidad de su escritura y de sus estructuras. Matemáticamente es un lenguaje torpe, pero no más que el ensamblador. Las órdenes se pueden introducir de dos formas, en castellano a modo [decir(algo), usar(esto)] o en un lenguaje minimalista basado en el inglés [wrt(texto), cp(función)] ésta doble sintaxis existe principalmente para no cerrar el programa a los usuarios hispanohablantes únicamente. Un repaso rápido del lenguaje:

Reglas:

1. Cada línea debe de contener al menos un parentesis, es decir los dos caracteres ( y ), éste último indica al compilador el paso a la siguiente órden.
2. El bloque a ejecutar al iniciar el programa es "main" (sobre mini so ccp)
3. Las operaciones con datos se hacen siempre de una en una, el contenido del paréntesis indicará la variable en la que queda el resultado [1 + 1(var_res)], siempre debe de haber un espacio antes y otro después de los operandos.
4. Si se manda sumar un número con un texto por error el valor del texto será interpretado como 0.
5. Si se manda una operación boleana a una variable que no es boleana (0 o 1) ésta valdrá 0 si está vacía o 1 si contiene cualquier cosa.
6. Todo dato se lee de una variable o definición y siempre, tras ser transformado se guarda en otra indicada.
7. Todas las variables son públicas. (si, tampoco me gusta mucho a mi... quizás en la próxima capa)
8. Toda orden no reconocida será ignorada

operadores matemáticos: +, -, *, /, &(concatenación),=(declaración)

operadores boleanos: and or not

ejemplo de código mancer (adivina el número en mancer):

v(val_yo,0)
v(val_jugador,0)
v(interruptor,0)
v(val_min,1)
v(val_max,100)

llamar(iniciar_juego)

>(iniciar_juego)
rnd(val_min,val_max,val_yo)
posicion(intentar)
pedir(estoy pensando un numero de 1 a 100 intenta adivinarlo!,val_jugador)
llamar(jugada,val_jugador)
saltar(intentar)
<()

>(jugada)-(val_jugador)
val_jugador == val_yo(interruptor)
si(interruptor)
decir(ACERTASTE)
rnd(val_min,val_max,val_yo)
saltar(finjugar)
fin()
val_jugador > val_yo(interruptor)
si(interruptor)
decir(demasiado alto)
saltar(jugada_intentar)
fin()
decir(demasiado bajo )
posicion(jugada_intentar)
decir(INTENTA OTRA VEZ)
posicion(finjugar)
<()

Éste código (30 líneas) genera un programa escrito en TurboTronasm de 112 líneas, no es mucho, pero aún se puede optimizar. Antes de un mes estará todo disponible, intentaré también crear una zona en el hacklab virtual con información sobre el lenguaje y la herramienta.

editado: (La herramienta ya está disponible para la descarga.)  descargar

El proyecto TurboTron

TurboTron es el nombre que he dado al proyecto de construcción de una serie de ordenadores virtuales escritos en lsl y ossl específicamente para OpenSim (en honor de la película de 1982 de Steven Lisberger). La idea vino tras varias pruebas en un servidor StandAlone con modificaciones del script "Assembly-Like Programming Language" de "Xaviar Czervik" el cual me ha servido de soporte para mi versión. Éstas máquinas virtuales son capaces de interpretar su propio lenguaje ensamblador (TURBOTRONasm) de diseño simple y versatil, compatible con direccionamiento dinámico para crear macros y funciones. La complejidad de la cpu ha sido aumentada para simular funciones comunes como un contador, una pila (utilizada para el regreso despues de macros), un acumulador de entrada (para el teclado numérico) y una memoria solo lectura para la recepción de parámetros y flags. En lugar de una memoria existen tres, la ram, desde donde se leen los programas y se puede escribir temporalmente, la memoria gráfica que acumula información de una línea de píxeles* y una memoria de pares, donde guardar la información referenciada con un nombre. También hay una memoria externa y no volátil en la que se escribe a través de interrupciones.

El cpu llega a ser alrededor de 300 veces más rápido que la versión de Xaviar Czervik gracias a un hack que multiplica el número de lecturas por cada ciclo, dispone de más memoria y un lenguaje mejorado para funcionar con datos dinámicos. La velocidad ha sido calculada con un bucle de 5 líneas de código y puede llegar a los 550 ciclos por segundo (con un multiplicador de 300). La ram guarda los datos en modo texto (string por celda) por lo que queda legible "en caliente", lo que permite un seguimiento completo de los procesos. La capacidad de la memoria ram es la misma de la clase array en C#.

Arquitectura de cpu:

reg0, reg1, reg2: Los registros de uso general, los he mantenido desde la versión de Xaviar Czervik.
counter: El contador, con llamadas especiales para sumar, restar y poner a cero.
pilret: la pila de regreso, funciona automáticamente para dar soporte a "return" tras una llamada a macro/función "call".
flags: la memoria de banderas, se usa para leer información adicional tras un mandato (parámetros de funciones, debug, mod tras una división etc...)
inbus: El acumulador del bus para las entradas de teclas (no botones de panel).

pointer: Indica la posición del cabezal lector sobre la memoria ram, (puede ser cambiado con goto, jump o call)

-parte gráfica (no se usa actualmente):
cgav: vector caché para guardar información de un color.
cgax, cgay: puntero caché de posición bidimensional.
cgat: minimemoria caché para guardar información sobre una textura
gmemory: memoria gráfica sobre la cual se puede escribir la información completa de una línea de píxeles para enviarla de una vez.

Periféricos: Hasta ahora he diseñado varios periféricos funcionales de entrada y salida para la máquina:

Panel: Con leds de actividad y botones de encendido y reset, era necesario.
Debug: Botones para mandar interrupciones a la cpu que fuerzan el vuelco de las memorias al chat.
Dirkeys: un pequeño panel de botones (arriba, abajo, izquierda, derecha y ok)
pad numérico: un pad numérico de 15 teclas.
Consola: una consola de texto plano (hover text) de alta velocidad.
Tcga: una pantalla de 16*12 celdas capaz de cambiar de textura cada una de éstas independientemente. (versión alpha, es increíblemente lenta)
Ftlht: utiliza el mismo protocolo de la consola, pero dibuja una página de hipertexto sobre un prim. (solo para navegadores 2.0)
Hd0: un método simple de guardar información de manera persistente.

lenguaje de programación hasta hoy:

// comentario y primera linea
mode0 set tipo puntero 0
mode1 set tipo puntero 1
mode2 set tipo puntero 2
set0 guardar valor en puntero 0
set1 guardar valor en puntero 1
set2 guardar valor en puntero 2
def0 definir tipo y datos de reg0 en csv (coma separated values tipo,valor)
def1 definir tipo y datos de reg1 en csv (coma separated values tipo,valor)
def2 definir tipo y datos de reg2 en csv (coma separated values tipo,valor)
jump saltar a línea definida
fin finaliza el programa y vuelve a bios
jif_max saltar si reg0 es mayor que reg1*
jif_less saltar si reg0 es menor que reg1*
jif_match saltar si reg0 es identico a reg1*
jif_key saltar si reg0 es igual a cache_inbus*_
suma suma reg0 a reg1 y lo guarda en reg2 
resta resta reg0 a reg1 y lo guarda en reg2 
rand genera número aleatorio entre reg0 y reg1
load0 cargar dato de dirección dentro de reg0
load1 cargar dato de dirección dentro de reg1
load2 cargar dato de dirección dentro de reg2 (deshabilitado)
save0 guardar dato de reg0 en dirección de memoria
save1 guardar dato de reg1 en dirección de memoria 
save2 guardar dato de reg2 en dirección de memoria
chat decir por el chat en el canal 0
ftlout enviar información a través de bus ftl (texto plano, $cls limpia)
input pedir información al usuario a través de chat y guardarla en reg2
hdd.read pide y espera el dato y lo carga en reg0
hdd.write manda guardar reg0 en la posición indicada
reset resetea la máquina virtual
run_bios cambia la imágen de bios y reinicia la máquina
run_exe carga el programa de nombre reg0 y lo ejecuta
run_lslmod arranca el script de nivel bajo* indicado (lsl)
memshow muestra a traves del chat el contenido de la memoria
cpushow muestra a traves del chat el contenido de todos los registros de cpu
inventory.getname0 carga en reg0 el nombre del programa solicitado con reg0
inventory.getname1 carga en reg1 el nombre del programa solicitado con reg1
inventory.getname2 carga en reg2 el nombre del programa solicitado con reg2 (deshabilitado)
readline carga el texto de la línea indicada en reg2 (csv: texto,linea)
write escribe una nota en el inventario principal con el nombre indicado en parametro y el valor de reg0
counter.start inicializa el contador en valor 0
counter.set copia el valor int de reg0 en counter
counter.+ sumar uno a counter
counter.- restar uno a counter
counter.save guarda el valor de contador en el sector de memoria especificado
counter.get lee el valor de counter y lo situa en reg2

@ definir etiqueta de dirección dinámica (@[espacio]nombreetiqueta)
get0 copia a reg0 el valor de casillero-cpu indicado (reg1,reg2,counter,inbus,param)
guardar reg0 como parametro en la posicion indicada
saveparam guardar reg0 como parametro en la posicion dinámica indicada
loadparam cargar en reg0 el parametro dinámico indicado

saveparamnum guardar reg0 como parametro en la posicion absoluta indicada
loadparamnum cargar en reg0 el parametro absoluto indicado
savecsvparam parsear reg0 como csv (valores separados por coma) y guardarlo en paramlist
gtif_max saltar a etiqueta @ si reg0 es mayor que reg1*
gtif_less saltar a etiqueta @ si reg0 es menor que reg1*
gtif_match saltar a etiqueta @ si reg0 es identico a reg1*
gtif_key saltar a etiqueta @ si reg0 es igual a cache_inbus*
import carga el programa indicado en ram manteniendo la memoria actual.
debug guarda una imagen del estado actual del hardware en flags de 0 a 5 (cpu,ram,ref,prof,gmem,gpu)
cgasendpix enviar el cache gráfico como píxel no cacheado en gmemory.
cgapixset definir un pixel cgi en cache a traves del valor de action (x,y,R,G,B)
cgalinsave guardar la cache en todos los casilleros de memoria gráfica (linea)
cgapixsave guardar la cache a la memoria grafica 
cgaout envia la memoria grafica actual a traves del bus adecuado
cgacls limpiar la memoria grafica
cgat.set pone valor txt en el mismo valor que action
cgax.set pone valor x en el mismo valor que action
cgay.set pone valor y en el mismo valor que action
cgax.+ suma 1 al valor cgax
cgax.- resta 1 al valor cgax
cgay.+ suma 1 al valor cgay
cgay.- resta 1 al valor cgay
cgav.set definir el valor de vector-color (cache R,G,B)

Por otro lado también estoy trabajando en una especie de minikernel con funciones recurrentes con la idea de preparar un pequeño sistema operativo primitivo que gestione la máquina, más por investigar que por cualquier otra cosa. Esta versión aun no está acabada al 100% y no me gustaría que existieran cientos de versiones incompatibles entre ellas, por lo que por ahora no se puede copiar, pero existen dos versiones de muestra disponibles, una de ellas (tronassembler 1700) es una versión muy parecida a la de Xaviar Czervik pero que no depende del evento database, el otro dispone de un multiplicador de cpu y varias optimizaciones en el código y el pad numérico. Éstas versiones no son compatibles con el nuevo lenguaje ni con las referencias dinámicas, pero es también muy didáctico por su simplicidad.

Puedes copiarlas, encontrar información y software o probar la versión nueva en el metaverso en mi hacklab en OsGrid:

http://slurl.com/secondlife/ABDERRAMAH/113/94/26

Primeros tutoriales de agente matrix en 3D en osgrid

Ya es posible encontrar la documentación de agente matrix en soporte 3D en el metaverso libre OsGrid. Desde aquí es posible también descargar directamente el programa, así como testear scripts. Posición:  secondlife://ABDERRAMAH%20LABS./112/57/26/?title=ABDERRAMAH

Nuevo servidor de realidad virtual en OSGRID

He comenzado la construcción del sim "ABDERRAMAH" conectado a la red OSGrid el cual servirá como soporte para múltiples servicios como:

* Biblioteca de scripts: donde almacenaré una gran colección de scripts útiles con permisos de edición.
* Cine libre: una sala emite cortos y otra documentales.
* Hacklab: Gran edificio donde espero situar tutoriales de programación e iniciación al hacking.
* Klystron Disco: Donde nunca suena música pija: Rap, electro underground, industrial, rock, punk...

El acceso es libre, tan solo accede a osgrid y usa el buscador del mapa: ABDERRAMAH (junto a SINDESTINO)

AGENTE MATRIX lsl tool, editor de código lsl

Agente matrix es un editor de código LSL organizado por eventos y basado en la adición de fragmentos de código testado. Es muy fácil crear códigos simples o complejos de éste modo. Se incluyen también una serie de "frameworks" o colecciones de funciones para añadir nuevas funcionalidades al lenguaje. El resultado es un entorno de desarroyo potente, general y a su vez simplificado. Compatible con windows Xp Vista y 7. Puedes descargarlo desde aquí: Descarga

Herramientas de sistema y seguridad gratuitas

Como el nombre dice aquí tienes una selección de herramientas gratuitas para el correcto mantenimiento del sistema y gestión de seguridad. [fuente: http://www.noticiasdot.com/wp2/2010/07/15/ahrrate-un-montn-de-dinero-los-mejores-programas-gratis-para-tu-pc/] Windows 7 SP1 Beta Primera versión beta del primer pack de actualizaciones de Windows 7. Incluye algunas de las herramientas que estarán presentes en el pack final aunque hemos de prevenir que al tratarse de una versión beta algunas pueden no funcionar correctamente. Entre las novedades, Soporte para USB 3.0 y mejoras para conexión a redes Wifi y Bluetooth. Otras interesantes son la herramienta Remote FX que nos permitirá acceder al escritorio de Windows remotamente aprovechando sus recursos multimedia como la interface Aero y Silverlight. Disponible en inglés, francés, alemán y español. Descarga ________________________________________________________________________________ Microsoft Fix It Center Este programa nos permitirá encontrar y corregir problemas que se producen en nuestro sistema operativo con la garantía de Microsoft, esta aplicación nos permite corregir automáticamente hasta más de 300 problemas detectados de manera muy fácil…. Para usarlo necesitamos una cuenta de Windows Live Descarga ________________________________________________________________________________ CheckDriv Esta excelente aplicación analiza y corrige los eventuales problemas de nuestro disco duro. Primero analiza el contenido y si encuentra algún error lo repara. Descarga ________________________________________________________________________________ Auslogics Task Manager Complemento ideal para el Administrador de tareas de Windows, nos permite gestionar los procesos y programas que están en ejecución o que están bloqueando el desempeño del equipo. Destacamos el hecho de que en los listados las aplicaciones confiables son mostradas con un icono en verde. Esto nos permitirá eliminar aquellos sospechosos de nuestro equipo. Descarga ________________________________________________________________________________ Auslogic System Information Permite chequear un equipo a fondo, desde la versión del sistema operativo, memoria, disco duro, programas instadlos, hardware, desempeño, etc. La información es muy exhaustiva con detalles precisos. Ideal para pasárselo a un equipo nuevo y comprobar si realmente lo que nos han entregado es lo que nosotros habíamos pedido. Descarga ________________________________________________________________________________ AVZ Antiviral Toolkit Software gratuito para Windows XP, Vista y 7 Herramienta que escanea nuestro PC en busca de virus, adware, spyware… Una de las ventajas de esta aplicación es que cuando escanea el disco no deja el ordenador inservible y la velocidad es bastante aceptable. También podemos configurarlo para que busque solo determinadas amenazas. Descarga ________________________________________________________________________________ AVG Free 9.40 La versión gratuita de AVG proporciona una protección eficaz contra virus y demás amenazas conocidas de Internet. El antivirus es el núcleo central del programa. Utilízalo de forma periódica para analizar el ordenador, poner en cuarentena y eliminar cualquier aplicación maliciosa. Otra característica interesante de AVG Free es su sistema de protección residente, un mecanismo que supervisa todos los ficheros con los que trabajas para asegurarse que están libres de virus. AVG Free también protege el ordenador de la actividad del software espía y publicitario, que también conoceras como adware y spyware. Además, dispone de un filtro para el correo electrónico que es compatible con los principales clientes de email y una herramienta denominada LinkScanner que comprueba la fiabilidad de los enlaces de los principales buscadores. Descarga ________________________________________________________________________________ LinkScanner Es una herramienta esencial para navegar por la red ya que nos informa, tomando datos de Google, de aquellos lugares que han sido infectados por virus o bien están creado únicamente para contaminar nuestros equipos. Funciona junto a los navegadores más populares y es una excelente ayuda para advertirnos de si ese lugar que estamos visitando puede ser perjudicial para nuestro equipo. Descarga ________________________________________________________________________________

PRESENTACIÓN

¿Que puedes encontrar aquí?

Como el título indica, software experimental creado por abdlab, o software gratuito y/o libre, además de noticias tecnológicas relacionadas con programación, mundos de realidad virtual, hacking e internet

en general; pequeños tutoriales y apuntes así como información sobre el estado de varios proyectos de software que llevo a cabo.

¿Que es Abdlab?

Un particular, nada que ver con una empresa ni comunidad. El software de abdlab que aquí se comparte es el producto de mis horas de ocio. Mis programas generalmente funcionan sobre windows y están escritos en vb.net así como lsl y ossl para scripts de mundos de realidad virtual.

¿Y si no me interesa?

Pues no pierdas tu tiempo haciendo un comentario desagradable y lárgate a otro sitio.