Mensajes

Bueno, no exáctamente, aunque hay muchas similitudes. Me he inspirado en las estructuras grid e hypergrid de opensim, un tema complejo que he tratado de simplificar al máximo. La idea es que los servidores se agrupan en una rejilla ("grid") y además un cliente puede conectar a diferentes rejillas. Una rejilla contiene información de sus usuarios registrados, pero además puede albergar información "importada" desde otro servidor. Así un usuario pùede ser teletrasportado a una rejilla en la que no tiene cuenta sin problemas. Un mismo servidor puede pertenecer a varias de éstas grids al mismo tiempo. Opensim puede operar en varias estructuras diferentes a la que yo he escogido, es un tema muy interesante. http://opensimulator.org/wiki/Hypergrid

Primero hay que definir qué hace a una forma de vida, para poder definir la muerte. Muchos han dicho que somos átomos, de hecho es la idea aceptada por la ciencia, pero a mi me parece que es erronea. No digo que nuestra materia no esté formada por átomos, es más complicado. La vida es muy peculiar, porque de algún modo cada átomo se sitúa donde debe, creando un sistema altamente entrópico llevando la contraria a todo lo que no está vivo que por sí solo disminuye su entropía con el paso del tiempo. Si la vida son sólo los átomos porqué muestra un comportamiento tan diferente del resto del univeso.

Por otro lado está el hecho de que la vida tiene unos patrones que se autorreplican a diferentes escalas, si, se autorreplican usando átomos, pero yo entiendo como "vida" al propio patrón que impulsa ese aumento de la entropía en contra de toda ley. Por no hablar de el hecho de la consciencia y la percepción de nosotros mismos, cosas que la ciencia pasa por alto debida la complejidad del tema. Queramos o no somos conscientes de nosotros mismos, propiedad que compartimos con parte de las formas de vida conocidas y no somos capaces de explicarlo. La reflexión filosófica sería:

¿si meto todos mis átomos en un bote el resultado soy yo?

nosotros morimos, pero todo no termina ahí, el patrón que hemos utilizado temporalmente seguirá vivo y evolucionando, aumentando su complejidad y en definitiva, ganando entropía.

Si la ouija en un momento dado funciona no estás contactando con espíritus, sino con tu propia mente.

se puede usar goto a una etiqueta para hacer el primero.

bucle:
console.writeline("BORRACHO YO? tururú")
goto bucle

Yo estoy investigando y tratando de crear otra arquitectura diferente, la llamo de "servidor pasivo" donde el servidor NUNCA inicia una conexión con un cliente, al contrario solamente responde a las órdenes de los clientes, que pueden ser de lectura o escritura al más puro estilo base de datos. Son los clientes los que "procesan" el mundo. ¿y los comportamientos integrados en el propio mundo? bien, aquí llega lo complicado.

Cada mapa de este juego (por ahora chat 2D) es alojado por un usuario, el cual es responsable de ejecutar los fragmentos de código contenidos por el mapa y enviarlos al servidor. Es ineficiente en cuanto a ancho de banda, puedo moverlo en red local, pero por vpn fue imposible, ¿el beneficio? el servidor ocupa 21 kb, y se podrían correr muchos en una sola máquina, cada uno en un puerto diferente.

Faltan atar muchos cabos, la idea es que el mundo sea descentralizado, o sea, que gran parte de éste sea creado y mantenido por cada cliente. Por supuesto hay un tipo de servidor independiente que se puede abrir, pero aun tengo que resolver el problema de los códigos (puertas que se abren, botones, sillas pàra sentarse etc...)

entonces mi sistema es así:

1- abre el cliente y pregunta user, login y servidor.

2-se piden los datos del servidor (nombre, array de mapa e información de los posibles bloques de mapa y de avatar con los que se construyen los gráficos)

3- se piden los datos del usuario, los cuales incluyen la última posición registrada y la apariencia (en tres capas). Se pide el mapa señalado en última posición.

4- se precarga una imágen de cada capa del mapa así como otra de la fusión de todas las capas del avatar. se dibuja la escena y se crea un registro en el servidor para indicar que se está online y en dicho mapa.

5- a partir de entonces corre el main loop, el cual se encarga de pedir continuamente la información de cada usuario del mapa y de subir la suya propia, luego lee todos los registros de otra carpeta que guarda los mensajes que son audibles al avatar.

Falta mucho, pero quiero que el mapa esté compuesto de diferentes servidores (modo grid) y que cada uno disponga de sus propios assets y listas de usuarios. Un servidor podría enviar a un avatar propio desde ahí hasta cualquier otro servidor, no sería necesario crear cuenta, y pasaría con sus propiedades (hypergrid). Es ambicioso y posiblemente una mala decisión de ingeniería, pero poco a poco va tomando forma.

unas imágenes del proyecto: http://abdlab.blogspot.com.es/2012/04/proximos-proyectos-imagenes.html

No lo contiene exáctamente, lo llama y le da órdenes para compilar tu código, el compilador (que digamos contendría el lenguaje) es una herramienta que usa el ide. Como te han explicado antes, el ide sólo hace más fácil la tarea de escribir código correcto y compilarlo. un  saludo.

Ahí va una lista de funciones en vb.net para efectuar las operaciones con imágenes más simples pero más necesarias para usar el interface GDI+. Al usar múltiples capas, por ejemplo en un personaje con ropa donde provienen de diferentes imágenes es una buena idea usar la función add_layer para superponer las dos imágenes y utilizar en adelante la imágen acoplada, así sustituimos 2 pasadas de dibujo, o las que nos sean necesarias por tan sólo una. Otra buena idea es usar la carga con resolución fija, para así disponer de imágenes más ligeras de manejar y por lo tanto de dibujar. Dado que las funciones de dibujo de texto requieren muchos parámetros en el interface gdi+ incluyo también varias funciones de rasterizado de texto, las cuales devuelven una imágen con el texto impreso. Las funciones están sobrecargadas, hay dos o tres versiones de cada una con diferente número de parámetros.
Cualquier duda me preguntais.

'leer una imágen desde archivo
Public Function read_image(ByVal file As String) As System.Drawing.Bitmap
        Dim img As New Bitmap(file)
        Return img
    End Function

    Public Function read_image(ByVal file As String, ByVal sizex As Integer, ByVal sizey As Integer) As System.Drawing.Bitmap
        Dim img As New Bitmap(file)
        Dim b As New Bitmap(sizex, sizey)
        Dim bg As Graphics = Graphics.FromImage(b)
        bg.DrawImage(img, New Rectangle(New Point(0, 0), New Size(sizex, sizey)), New Rectangle(0, 0, img.Width, img.Height), GraphicsUnit.Pixel)
        Return b
    End Function

'redimensionar una imágen
    Public Function resize_bmp(ByVal img As Bitmap, ByVal sizex As Integer, ByVal sizey As Integer) As Bitmap
        Dim b As New Bitmap(sizex, sizey)
        Dim bg As Graphics = Graphics.FromImage(b)
        bg.DrawImage(img, New Rectangle(New Point(0, 0), New Size(sizex, sizey)), New Rectangle(0, 0, img.Width, img.Height), GraphicsUnit.Pixel)
        Return b
    End Function

    Public Function resize_bmp(ByVal img As Bitmap, ByVal size As Size) As Bitmap
        Dim b As New Bitmap(size.Width, size.Height)
        Dim bg As Graphics = Graphics.FromImage(b)
        bg.DrawImage(img, New Rectangle(New Point(0, 0), New Size(size.Width, size.Height)), New Rectangle(0, 0, img.Width, img.Height), GraphicsUnit.Pixel)
        Return b
    End Function

    ' extraer una porción de una imágen
    ' image = imagen a recortar
    ' cuadriculax y cuadriculay = número de sectores por cada dimensión
    ' sectorx y sectory = vector puntero de la selección
    Public Function get_portion(ByVal image As System.Drawing.Bitmap, ByVal cuadriculax As Short, ByVal cuadriculay As Short, ByVal sectorx As Integer, ByVal sectory As Integer) As System.Drawing.Bitmap
        Dim img As New Bitmap(CInt(image.Size.Width / cuadriculax), CInt(image.Size.Height / cuadriculay))
        'Dim b As New Bitmap(CInt(image.Size.Width / cuadriculax), CInt(image.Size.Height / cuadriculay))
        Dim bg As Graphics = Graphics.FromImage(img)
        Dim tmpx As Integer = (image.Size.Width / cuadriculax) * sectorx
        Dim tmpy As Integer = (image.Size.Height / cuadriculay) * sectory
        Dim port As New Rectangle(New System.Drawing.Point(0, 0), New Size(New Point(image.Size.Width / cuadriculax, image.Size.Height / cuadriculay)))
        bg.DrawImage(image, port, tmpx, tmpy, CInt(port.Size.Width), CInt(port.Size.Height), GraphicsUnit.Pixel)
        Return img
    End Function

    Public Function get_portion(ByVal image As System.Drawing.Bitmap, ByVal cuadricula As System.Drawing.Size, ByVal sector As System.Drawing.Size) As System.Drawing.Bitmap
        Dim img As New Bitmap(CInt(image.Size.Width / cuadricula.Width), CInt(image.Size.Height / cuadricula.Height))
        'Dim b As New Bitmap(CInt(image.Size.Width / cuadricula.Width), CInt(image.Size.Height / cuadricula.Height))
        Dim bg As Graphics = Graphics.FromImage(img)
        Dim tmpx As Integer = (image.Size.Width / cuadricula.Width) * sector.Width
        Dim tmpy As Integer = (image.Size.Height / cuadricula.Height) * sector.Height
        Dim port As New Rectangle(New System.Drawing.Point(0, 0), New Size(New Point(image.Size.Width / cuadricula.Width, image.Size.Height / cuadricula.Height)))
        bg.DrawImage(image, port, tmpx, tmpy, CInt(port.Size.Width), CInt(port.Size.Height), GraphicsUnit.Pixel)
        Return img
    End Function

' sobredibujar una imágen sobre otra
    Public Function layer_sum(ByVal layer1 As Bitmap, ByVal layer2 As Bitmap) As Bitmap
        Dim bg As Graphics = Graphics.FromImage(layer1)
        bg.DrawImage(layer2, New Point(0, 0))
        Return layer1
    End Function
    Public Function layer_sum(ByVal layer1 As Bitmap, ByVal layer2 As Bitmap, ByVal offsetx As Integer, ByVal offsety As Integer) As Bitmap
        Dim bg As Graphics = Graphics.FromImage(layer1)
        bg.DrawImage(layer2, New Point(offsetx, offsety))
        Return layer1
    End Function

' dibujar una imágen de texto rasterizado
    Public Function get_text_layer(ByVal size As System.Drawing.Size, ByVal text As String) As System.Drawing.Bitmap
        Dim img As New Bitmap(size.Width, size.Height)
        Dim bg As Graphics = Graphics.FromImage(img)
        bg.DrawString(text, New Font("Arial", 12, FontStyle.Bold), Brushes.Black, New Point(1, -1))
        bg.DrawString(text, New Font("Arial", 12, FontStyle.Bold), Brushes.White, New Point(0, 0))
        Return img
    End Function

    Public Function get_text_layer(ByVal sizex As Integer, ByVal sizey As Integer, ByVal text As String) As System.Drawing.Bitmap
        Dim img As New Bitmap(sizex, sizey)
        Dim bg As Graphics = Graphics.FromImage(img)
        bg.DrawString(text, New Font("Arial", 12, FontStyle.Bold), Brushes.Black, New Point(1, -1))
        bg.DrawString(text, New Font("Arial", 12, FontStyle.Bold), Brushes.White, New Point(0, 0))
        Return img
    End Function

    Public Function get_text_layer(ByVal sizex As Integer, ByVal sizey As Integer, ByVal text As String, ByVal fontsize As Integer) As System.Drawing.Bitmap
        Dim img As New Bitmap(sizex, sizey)
        Dim bg As Graphics = Graphics.FromImage(img)
        bg.DrawString(text, New Font("Arial", fontsize, FontStyle.Bold), Brushes.Black, New Point(1, -1))
        bg.DrawString(text, New Font("Arial", fontsize, FontStyle.Bold), Brushes.White, New Point(0, 0))
        Return img
    End Function 'code by abderramah

Reactos, es un sistema operativo compatible con windows, no oficial, supongo que a partir de ingenierías inversas etc, pero nunca he podido instalarlo y bueno, la apariencia es como la de windows 2000.

Ah, pues el consumo en win8 es muy parecido al de win7. También tengo que decir que en pcs actuales, en mi experiencia, windows7 rendía mejor que xp. Es cierto que consume más ram mientras andas en el escritorio, pero esto se debe a ciertas mejoras que lleva con respecto a xp, como el indizador que está siempre funcionando y hace que la búsqueda de archivos sea más rápida así como todos los efectos visuales, transparencias etc.

A la hora de correr un programa exigente, que haga uso de efectos gráficos o sonidos (por ejemplo photoshop) el rendimiento de windows 7 con 1gb o más de ram es muy bueno, a pesar del susto que te puede dar ver 600 y pico mb consumidos sólo por tener el sistema en reposo.

Si, usando el componente iexplorer de .net es muy sencillo.