Wenas.

Puede que hace unos años no me imaginara nunca haciendo esta pregunta, pero después de haber pasado por diferentes y variadas empresas (siempre que hicieran juegos, si es que eso se puede considerar variación XD), y haber visto lo que se cuece ...

El tema es que estoy desarrollando en casa un frame-work multiplataforma para PC y consolas next-gen (si, ya se que soy muy original). Basicamente se compone de una aplicacion/editor con soporte para plug-ins (de echo la mayoria de la funcionalidad está alojada en las .dll de los plugins) en C# (winforms/.NET), una serie de wrappers C++/CLR, y un player en C++ (bueno, uno para cada plataforma).

Mi problema ahora es como licenciarlo (entregar el software) y no arriesgarme a que me hagan la 3-14 (tb conocida en mi pueblo como: "la jugada fosca").

Para simplificarlo he decidido varias cosas:

* No distribuir el source de nada.
* Se podrian seguir desarrollando plug-ins para ampliar el editor.
* La "programación" seria completamente en script (de momento soporto Lua, aunque estoy pensando en integrar Python y Squirrell)
* El player siempre tiene la pantalla de splash, de modo que solo sirva de visualizador (tanto en el PC de desarrollo, como en la consola target)
* El editor no permita realizar el "empaquetado final" de los assets
* Para los masters o candidates versions que se deban enviar para checking a la compañia de la consola seria imprescindible que realizara yo la build final.
* El sistema de control de licencia solo esta instalado en el editor (desarrollarlo en C# es muchisimo más comodo).


El problema es que por mucho que le meto (y se me ocurre poner) al control de licencia:
* Guardado de datos sensibles encriptados
* Creación de Bulk Keys y License Keys
* Trial versions
* Caducidad de la licencia
* Control de cambio de fechas
* Verificación de licencia por servidor
* Grabacion y comprobacion de datos en registro de windows.

No me quito la sensacion que todo parece resumirse en que como alguien se salte el "if (LicenseManager.ChekValid())" que hay cuando arranca el editor todo esfuerzo es inutil.

He estado indagando en programas comerciales que te ofrecen soluciones en apariencia muy completas, pero a la hora de integrar (por los ejemplos que he visto) en tu programa es lo mismo, si alguien se salta el if ... hasta luego lucas.

He pensado en poner mas comprobaciones de licencia durante la ejecución de la aplicación, pero poca cosa más se me ocurre.

¿ Alguien está más familiarizado con esto?

Se que Vicente tiene idea (por no decir que es Dios) de todo el tema del .NET, el codigo que se produce al compilar, como decompilarlo, que si CLR, que si CLI, y todo eso que practicamente desconozco.
Mi pregunta tb seria como de facil es "reventar" una aplicacion de .NET para saltarse el if, o intentar trazar el comportamiento de la aplicacion, para descifrar  los algoritmos, claves y procedimientos del sistema de licencia. Sobretodo comparado con c++, porque tb habia pensado en hacer el sistema en c++ y ponerlo tanto en el player como en el editor (para lo que seguramente haria un wrapper C++/CLR y una bonita .dll).

Gracias de antemano a todos y un saludo.

Si no recuerdo mal, en comandos1 no habían pisos, pero en el 2 sí.

En el uno podias ir navegando por el agua con la barca justo debajo de un puente por el que podias ir andando si no recuerdo mal. Esto serian "pisos", pero se podria solucionar si un bit indica si es "walkable", y otro si es "navegable". El dibujar el puente por encima o no se solucionaria con la info de z(orden de dibujado).
Con más información se podria indicar un rango de altura actual en la posicion en el mapa de durezas, y limitar el paso de una altura a otra, etc.
Tambien se podrian tener mapas de "sectores" para diferentes pisos y zonas del mapa, y hacer "links" entre ellos.

No sé, son ideas.

Salu2

[Y]

...
ademas el sistema tenía información 3d muy simplificada de la geometria de la escena, y es la que utilizaba para temas de colisiones, campo de vision de las entidades, etc.

...

¿Estas seguro? A mi me suena que en el Comandos se pintaban las colisiones, sectores, etc en photoshop en una capa encima de la imagen ya renderizada, esta capa se exportaba aparte y se utilizaba como mapa  de "durezas" (como lo llamaban en el Div). Digo me suena, por que me lo contaran asi, yo NO he currado en Pyro.

De este modo las coordenadas del personaje se pueden mantener 2D(x,y) y no hace falta tener la representacion 3D(x,y,z) y tener que ir pasandola a 2D para situar el sprite a renderizar (esto quizas seria mejor para un estilo Marble Madness en "isometrico puro").

El mapa de durezas (MD) puede tener cualquier representacion parecida a una imagen (matriz NxM), aunque al no tener que dibujarse (excepto por casos de depuración) deberia estar en RAM de CPU para realizar las comprobaciones (aunque actualmente se podrian trabajar con modelos de shader > 3 y con las texturas en memoria de tarjeta).
En un ejemplo de color indexado a 256 colores tenemos un byte para cada pixel del MD, del que podemos utilizar por ejemplo 3 bits(8valores) para indicar el nivel de z (como orden de dibujado respecto a otros elementos), tres mas para el tipo de terreno (bloqueado, hierba, nieve, agua,  ...) y nos quedan dos bits que podemos utilizar para cualquier flag.

Otra cosa es que tampoco necesitas la resolución de la imagen de visualizacion, asi que podemos tener un mapa un 25% más pequeño(por ejemplo), y para encontrar la correspondencia del mapa de render con el de durezas solo tenemos que dividir por cuatro:

Código [Seleccionar] Expand

// (suponiendo que utilizamos valores enteros como coord 2D)
xdurezas = (xscreen + xscroll) >> 2; ydurezas = (yscreen + yscroll)>> 2;

Tambien debes tener en cuenta que los sprites que esten dentro del mismo z (orden de dibujado) se deben dibujar segun su coordenada Y (que deberia de estar en el "bottom" o pies del objeto/sprite), de modo que el "personaje" que tenga los pies con mayor Y (más abajo) se pintará después que el que los tenga más "alto".

Por ultimo opino que los pathfinding (A*, crash&turn, etc) pueden funcionar mejor (mejor tiempos de ejecución, y mayor facilidad de implementación)  con esta representación que con representación 3D.

Pero es solo una opinión.
¿Alguien se le ocurren otras implementaciones o porque seria mejor utilizar representacion interna 3D de las coordenadas y pasarlas a 2D solo al dibujar?

Salu2

Hay una relación entre el tipo de pipeline de contenido que utilices y el formato al que debes exportar.

Ante todo (como dice tamat) lo mejor es cargar un formato directo (lo más semejante a un Load-InPlace será lo más efectivo para los tiempos de carga). Diseñado especificamente para las necesidades de tu motor.

Si utilizas una pipeline basado en exportación (como Ogre por ejemplo), deberias exportar desde tu programa de edición directamente tu propio formato (mediante un plug-in como dice tamat).

Si utilizas pipeline basado en importación (como Unity, Phyre, XNA, ...) lo normal es exportar Collada o FBX. Puedes tener funciones de carga directa desde el FBX o Collada (que permiten rapida visualización, trabajo colaborativo en el caso de collada, etc), y funciones de conversion a formato propio, que es el asset final que incluirias en la build de juego.


Las ventajas del pipeline de contenido basado en importacion para mi son bastante claras. De todas formas dejo un link a un buen articulo de gamasutra: http://www.gamasutra.com/view/feature/4085/sponsored_feature_the_.php, y cada uno que decida su camino  :)


Salu2

Ese tipo de desorden a mi me suena a que la base de datos esta indexando, y los ordena conforme le viene.
O que al hacer la consulta llegan de forma diferente cada vez, no sé.

Pero creo recordar que las listViews se podian ordenar por campo. Creo que se podia setear desde código y desde el editor de forms (me parece).
Aunque no suelo usar listView con "binding" a una base de datos, las utilizo para mostrar estructuras de datos internas, y modificarlas.

EDIT: Nada, me he rallao, creia que decias una DataGridView  ::)

^^

adew!

Hola,

al final conseguí que rulara en la máquina Mono. Cuando obtenia el assembly con getExecuting solo me devolvia las clases que tenia registradas en el editor, pero al final pude obtenerlo a partir de la clase ArbolCompo y con un par de cambios más funciona bien :)

Por desgracia la maquina mono que utilizo no soporta LINQ y no puedo utilizar esos filtros  :( . Aunque la verdad me molan mucho, y para los editores en .NET la verdad es que es una caña (assetdb, busquedas sobre la jerarquia de escena, etc)  :D

Y ya puestos me molaria hacerte otra pregunta Vicente (si te viene bien claro :)).
Tu que sabes de IA y de C#.
Cuando comencé el diseño de los arboles estos, tenia pensado utilizar un objeto que fuera el Conocimiento del Agente, y que cuando se cambiara algo de él se marcara un flag de modificación, para que el árbol supiera que tenia que reevaluarse.

De forma automática en Lua lo que haria seria utilizar __newindex en la metatabla del objeto para indicar que todo cambio sobre ese objeto, activara el flag de modificado, y cuando acabara de evaluar el arbol deshabilitaria el flag manualmente.

En C# lo único que se me habia ocurrido era utilizar propiedades para cada variable del conocimiento, y cada set modificar el flag.
¿Se te ocurre una forma mejor? (la verdad es que no estoy muy puesto en c#)  ::)

Gracias nuevamente :)

ta luego

Al final me autocensto yo mismo   |:|

Con esto tengo automatizado la lista de strings de las clases derivadas de ArbolCompo y sus acciones y condiciones.
Eso si, los enums se tienen que llamar de una forma determinada (TipoDeAccion, TipoDeCondicion).
El truco esta en hacer el Init solo al crear la ventana del editor, cerrarla para modificar los enums o el numero de clases derivadas de ArbolCompo, y volver a abrir la ventana más tarde (con lo que recarga los cambios por reflexion).

Aqui funciona, lo probaré en el curro con la maquina Mono. Ya digo algo.

La verdad es que ha sido más sencillo de lo que esperaba.

Código [Seleccionar] Expand

class ArbolCompoHelper
{
    public static void Init()
    {
        Assembly assembly = Assembly.GetExecutingAssembly();

        // Obtenemos todos los types del assembly (igual un poco basto, pero weno)
        Type[] myTypes = assembly.GetTypes();
        List<Type> enemyBTs = new List<Type>();

        // Filtramos por los que sean subclase de ArbolCompo
        foreach (Type t in myTypes)
            if (t.IsSubclassOf(typeof(ArbolCompo)))
                enemyBTs.Add(t);

        // Creamos array de nombres de enemigos:
        int n = enemyBTs.Count;
        tiposDeEnemigos = new string[n];
        acciones = new string[n][];
        condiciones = new string[n][];
        // recorremos los tipos de los enemigos
        for (int i = 0; i < n; i++)
        {
            // seteamos el nombre
            tiposDeEnemigos[i] = enemyBTs[i].Name;
            // Buscamos y listamos los enums
            acciones[i] = ListaEnum(myTypes, enemyBTs[i].FullName + "+TipoDeAccion");
            condiciones[i] = ListaEnum(myTypes, enemyBTs[i].FullName + "+TipoDeCondicion");
        }
    }

    public static string [] ListaEnum(Type [] types, string nombre)
    {
        foreach (Type t in types)
            if (t.FullName == nombre)
                return Enum.GetNames(t);
        return null;
    }


    protected static string[] tiposDeEnemigos = null;
    public static string[] ObtenerTiposEnemigos()
    {
        return tiposDeEnemigos;
    }

    static string[][] acciones = null;
    static string[][] condiciones = null;

    static string[] ObtenerAcciones(int tipo)
    {
        return acciones[tipo];
    }

    static string[] ObtenerCondiciones(int tipo)
    {
        return condiciones[tipo];
    }
}

Espero que alguien le sirva de algo ^^

adew!

[[] string]

Lo he leído dos veces y debo estar super espeso, porque no lo entiendo :(

Pues si tú no lo entiendes mal vamos ... XD

El post en si es espeso. Además no sé si me explicado bien y el tema igual es un poco complejo.
Bueno, voy a intentarme explicar un poco mejor. El código está en el curro, pero pongo algo de ejemplo.
Es como un arbol de comportamiento (aunque más bien es un arbol de decision). Lo que pasa es que he simplificado algunas cosas ya que no dispongo de mucho tiempo para invertir en esto.
Actualmente tengo en el runtime algo parecido a estos scripts de c# (funcionan en Wii bajo la vm mono de Novell):

Código [Seleccionar] Expand


// Nodos del arbol
class NodoArbolCompo
{
    List<NodoArbolCompo> hijos;

    public void EjecutarNodo(ArbolCompo arbol)
    {
        // Evaluamos condicion
        if (arbol.EvaluarCondicion(this.condicion))
        {
            // Ejecutamos Acción
            arbol.EjecutarAccion(accion);
            // Recorremos hijos ...
            foreach (NodoArbolCompo nodo in hijos)
                nodo.EjecutarNodo(arbol);
        }
    }

    string condicion;
    string accion;
}

// Agente / gestion del conocimiento del agente
class IAAgent
{
    // ... esto es otra historia
};

// Arbol de comportamiento (más bien de decisión)
class ArbolCompo
{
    NodoArbolCompo raiz;
    protected IAAgent iaAgent;

    public ArbolCompo(IAAgent agent)
    {
        iaAgent = agent;
        // ....
    }

    public void EjecutarArbol()
    {
        raiz.EjecutarNodo(this);
    }

    public void CargarArbol(string resourceName)
    {
        // ...
    }

    public void SalvarArbol(string resourceName)
    {
        // ...
    }


    // Para sobreescribir por las clases derivadas
    public virtual void EjecutarAccion(string accion)
    {
        // NOTHING
    }

    public virtual bool EvaluarCondicion(string condicion)
    {
        return false;
    }
}

// Acciones y Condiciones especificas del malo1
class ArbolMalo1 : ArbolCompo
{

    public ArbolMalo1(IAAgent agent) : base(agent)
    {
        // ...
    }

    public override bool EvaluarCondicion(string condicion)
    {
        bool b = false;
        // ...
        return b;
    }

    public override void EjecutarAccion(string accion)
    {
        // ...
    }
}


Se que es un tostón pero he intentado simplificarlo al máximo  ^_^'
El rollo es que cada nodo del arbol tiene dos strings (accion y condicion), la funcion ejecutarNodo y una lista de hijos.
Y ArbolCompo tiene el nodo raiz, una refencia al agente, metodos para cargar/salvar el arbol y dos metodos para sobreescribir por las clases derivadas: EjecutarAccion y EvaluarCondicion. (como he dicho esta muy simplificado).

Bien ahora tengo el editor:


En el editor mantengo una copia de un objeto generico ArbolCompo, y utilizo los metodos de cargar y salvar. Las acciones y condiciones se editan en una textBox.
En runtime cargo el archivo en cualquiera de los derivados de arbolCompo y a funcionar.

Todo esto surgio en una versión de prueba, pero ha funcionado bien y tenemos que iterar y mejorarlo.
La primera cosa que pensé es que cada vez que evaluo el arbol debo comprobar los strings (lo hice asi es su momento para simplificar y de prueba) y es mas caro que comprobar enteros. Además del problema de equivocarte al escribir alguna cadena.
La solución es bastante clara, voy a sustiuir los strings de condicion y accion por un int en las funciones, y a a crear enums dentro de cada clase que derive de el arbol generico para las condiciones y las acciones.

El problema lo tengo en el editor.
Como solución rápida seria sustuir el string por el un id de un numero con la acción a realizar. Pero seria poco informativo ver el árbol de esa forma. Asi que me molaria tener una lista desplegable de opciones para cada acción y condición de cada nodo.
Además tengo que poner otra lista en de seleccion del tipo de arbol que estamos editando (cada uno puede tener unas acciones y condiciones diferentes).
Y de momento la interfaz de mi editor que tengo para llenar ese tipo de lista son un array de strings.

Editor deseado:


Entonces, primera solución para obtener los [] string de tipo de arbol, condicion y accion:

Código [Seleccionar] Expand

class ArbolCompoHelper
{
    static string[] tiposDeEnemigos = { "Malo1", "Malo2" };
    static string[] ObtenerTiposEnemigos()
    {
        return tiposDeEnemigos;
    }

    static string[] accionesMalo1 = { "Dispara", "SalCorriendo", "Pasea", "UrgarNariz" };
    static string[] condicionesMalo1 = { "VesEnemigo", "EnemigoCerca" }; // ...

    static string[] accionesMalo2 = { "LanzaGranada", "EchateAlSuelo", "Rascate", "DaOrdenes" };
    static string[] condicionesMalo2 = { "EnemigoATiro", "EstasCansado", "PocaVida" };

    static string[] ObtenerAcciones(string tipo)
    {
        switch (tipo)
        {
            case "Malo1": return accionesMalo1;
            case "Malo2": return accionesMalo2;
        }
        return null;
    }

    static string[] ObtenerCondiciones(string tipo)
    {
        switch (tipo)
        {
            case "Malo1": return condicionesMalo1;
            case "Malo2": return condicionesMalo2;
        }
        return null;
    }
}

Y en cada derivada de CompoArbol queria poner estos enums:

Código [Seleccionar] Expand

enum TipoDeAccion
    {
        Dispara = 0,
        SalCorriendo,
        Pasea,
        UrgarNariz
    }

    enum TipoDeCondicion
    {
        VesEnemigo = 0,
        EnemigoCerca
    }

   // Para poder hacer:

    public override bool EvaluarCondicion(int condicion)
    {
        bool b = false;

        switch ((TipoDeCondicion)condicion)
        {
            case TipoDeCondicion.EnemigoCerca:
                // ... return iaAgent.dist2Player < 1.0f;
                break;
            case TipoDeCondicion.VesEnemigo:
                // ...
                break;
        }

        return b;
    }

El problema es que para añadir una nueva acción (por ejemplo) tengo que añadir el enum y la lógica de EvaluarCondición en la derivada del ArbolCompo, y añadir por otra parte el nombre de la condicion en el array correspondiente de ArbolCompoHelper. (Y ambos estarán en .cs diferentes). Además no me puedo descuidar los indices ya que el nombre del array se tiene que corresponder con el indice que marca el enum correspondiente de cada clase.
Y la cosa es peor para añadir un nuevo enemigo, ya que tengo que definir en el heper sus arrays, llamarlos desde el case, etc.
Con lo que se me antoja complicado de mantener, y muy susceptible a errores (ahora tb lo es, pero se supone que lo tengo que mejorar).

Y después de todo este infierno de post  :-[ tengo solo 4 preguntas para usted señor Vicente  :-[ :-[ :-[ :-[
1) Puedo obtener al abrir el editor (y solo desde él) con reflexión un [] string con el nombre de todas las clases derivadas de ArbolCompo ??? Como?
2) Puedo obtener un array con los nombres de un enum ordenados segun su indice ??? (supongo que si xo ...) Como?
3) Puedo utilizar la info que he sacado del punto 1, para de alguna extraña forma acceder a un desglose (p.2) de un enum de esa clase selccionada? Comoooor?
4) ¿Alguna solución mejor?

Bueno, gracias y perdon por el peñazo, pero ya viene siendo habitual en mi estos post moliticos  0:-)

como dijo el sabio: Buenas noches y buena suerte
voy a dormiiiiiillll por hora

[string [] ObtenerTiposEnemigos()]

Hola, me encontrao con un problemilla scriptando algunas cosas del editor de arboles de comportamiento de nuestro ultimo juego.
Espero que alguien con más conocimientos de c# que yo me pueda decir si lo que quiero se puedo hacer.

Tengo una jerarquia de clases parecida a esta:
BehaivourTree (arbol generico)
-> Malo1BT ( deriva de BehaivourTree )
-> Malo2BT ( deriva de BehaivourTree )
-> ...

En mi editor por cada nodo me tienen que salir una lista de acciones y condiciones disponibles.
El problema viene cuando cada clase derivada (Malo1BT, Malo2BT, ...) tiene una lista de acciones y condiciones diferente.

En un principio (en teoria) tendria que tener el objeto final (Malo1BT, ...), entonces bastaria con que esta clase tuviera implementado un metodo ObtenAcciones/Condiciones que fuera abstracto (preferiblemente) enla clase genérica BehaivourTree.

Pues bien, el tema es que he implementado que cualquier clase derivada pueda cargar cualquier tipo de arbol. Por tanto en mi editor tengo un BehaivourTree genérico (no puedo hacerlo abstract), luego el arbol se graba como una serie de indices (int) en disco, y se carga en tiempo de ejcución ( ... y si, funciona bastante, bastante bien  ;) )

Pues bien, para que en el editor se sustituyan los indices por los nombres de las acciones y condiciones disponibles he pensao en obtener dos arrays de strings (1 x acciones y otro para condiciones). En el editor (parte superior izq) debe haber una lista con los tipos de arboles (por enemigo), y que indique que arrays de strings tenemos que obtener.

Por tanto para cada TIPO clase (Malo1BT, MaloBT2, ...) tengo dos arrays de strings ( acciones / condiciones ). Que se corresponden con los indices de un enum que tiene cada clase con sus acciones/condiciones.

Como obtenerlos:
1) Clase estatica "BehaivourTreeHelper" que contiene métodos estaticos para listar los tipos de enemigos ( string [] ObtenerTiposEnemigos() ). Y metodos para obtener acciones/condiciones por tipo de clase ( string [] ObtenerAcciones(Type p) o ObtenerAcciones(string nombreClase) ).

2) Mi problema es que defino enums con las acciones dentro de cada clase derivada (Malo1BT por ejemplo).
Y mantener los indices del array de strings en una clase diferente me parece un poco lioso.
Asi que preferiria escribir un método estático en cada clase que obtenga el array. Pero al ser estatico no puedo aplicar ningun tipo de polimorfismo (creo) para decir: todas las clases q derivan de BehaivourTree tiene ue tener un metodo ObtenAcciones, y luego obtener estas acciones dependiendo del tipo.

3) Lo cojonudo del todo seria poder además utilizar Reflexion (pensar que el coste me la suda un poco, porque estoy en el editor, no en el runtime del juego ni en el engine) y obtener las listas de strings a partir de los enums. Pero no tengo mucha idea. Quizás alguien (seguro) ha echo algo parecido y me puede dar una idea de como abordarlo.


Bueno, que opinais al respecto, ¿a alguien se le ocurre una solución?
Pues nada gracias a todos de antemano.

Nos vemos!!!

En DirectX se supone que eso *creo* se podia hacer mediante los SwapBuffers o SwapChains, creo que era algo como separar o tener dos buffers de renderizado que podias asociar a diferentes ventanas. Si le sirve a alguien entendido en materia como referencia para aconsejarte con algo mas detalle...

Las Swap de dx valen para no tener que crearte varios devices si quieres renderizar en varias ventanas, y no perder mucho rendimiento (ejemplo claro: world editor con varias ventanas de vista: front/top/left/perspective). Aunque si te creas varios devices con una swapChain por cada device también funciona. (lo he probao :) )
Pero en un principio (y remarco lo de "en un principio") no te dan información sobre el monitor que estas utilizando.
Hay samples en el DX_SDK de multiple monitor, y creo que es de donde más info se puede sacar (si vas a estar usando DX, claro).

No veo diferencia entre usar swing o un terminal de consola (eso depende de lo que tu estes imaginandote, cosa que no sé), la pregunta es clara, nunca mencioné la palabra 'juego'. ...

??? No hay diferencia? Bueno, creo que dejaré esto de programar, ... creo que vi unas opos por ahi para barrendero, igual ...
La palabra "juego" raramente deberia darse por sentada en un foro como este, de claro matiz taurino.

LA PREGUNTA DEL MILLÓN (lo que todos estabais deseando preguntar):
+ Porque no te creas dos ventanas. Colocas cada una en un monitor y en cada una pintas lo que te salga de los h****s quieras?????
+ Lo que quieres es una ventana que cuando la cambies de monitor cambie de color lo que estas renderizando en él?

Dios mio estoy perdido!! Menos mal que la pregunta estaba clara!!


Adew

Mantis

Mantis poweeeer!!
jejeje

1) Para planificación usaria Merlin (para MacOs, MsProject para windows) si quieres ir en plan diagramas de gantt y tal (pero las licencias de estos progrmas no son "baratas" precisamente, además que suelen ser un poco liosos y tienen su rollo).
Hay otras "alternativas" libres y basadas en java y otras teconologias multiplataforma que tb te pueden servir.
Utilizando MsProject, en una ocasión, hice un programa en C#/WinForms cliente que "se conectaba" al un documento de project compartido en la red interna y utilizaba las interOps para ofrecer una interfaz sencilla (y controlada) para el acceso a los proyectos por parte tanto de los "trabajadores" como de los "gestores del proyecto". Los incovenietnes son que cada ordenador que se conectaba debia tener instalada una copia del MsProject, además de otras tipo de cosas que han dejado de gustarme de la "planificación tradicional" que ofrecen este tipo de programas.

2) Yo en cada empresa que he currado (exceptuando las que tenian un sistema propietario similar) he acabado instalando un apache con php y MySql y rulando un Mantis. Puedes usarlo y configurarlo como quieras, y con un poco de tiempo te puedes montar un buen servicio web para tu intranet que te lo maneje todo (docs con semaforos, tareas, bugs, svn, etc).
Hay otras aplicaciones de servicio web que estan bastante bien tb (google is your friend). Y si quieres llevar un buen control de bugs, issues y features con varios testers (sobretodo si estan en otros estudios o un poco "lejos") al final tendrás que pasar por aqui.

3) Si quieres algo más sencillo el ToDoList (busca en codeProject) esta muy bien, pero creo que no hay port para MacOs (aunque si tienes algo de tiempo podrias echarle un ojo ya que creo que distriuyen el source), y realmente es de las mejores y más sencillas aplicaciones que he visto de este tipo.

4) Si tiras más hacia el desarrollo ágil: "Everybody loves Excel". En mis últimos proyectos utilizo backLogs en excel con unos cuantos macros en VB que me permiten automatizar bastantes cosas de manejo de tareas. También es una opción si lo integras con MsProject para que te saque gantts o algún tipo especifico de informe.
No sé hasta que punto paquetes "Office abiertos" como Open o Star Office pueden rular macros ni de que tipo son, pero tb son buenas alternativas.

5) GoogleDocs está bastante bien sobre todo porque puedes utilizar los dataSheets para las tareas y los bugs. Además de que siempre que tengas conexión puedes acceder a ellos (prácticamente desde cualquier lugar). Pero que yo sepa no hay soporte para scripts o macros que te permitan automatizar la gestión de tareas en los dataSheets.


Al final hay muchas opciones, y ninguna es la mejor, depende bastante de tu tipo de proyecto, tu forma de trabajo, etc.


Espero haber servido de alguna ayuda :)

Adew!

PS: El RedMine no tiene mala pinta, igual un dia le echo un ojo (dios!, necesito tiempoooooooo)  :(

[EDIT] -> Muchos IDEs tb permiten una gestión de TODOs y otro tipo de tareas básicamente de programación, con el añadido de que puedes meterlo en el código directamente con comentarios del tipo:

Código [Seleccionar] Expand

// TODO implementar x
// TOFIX optimizar z
aunque supongo que ya lo sabias  ::)

Hola,

el Phyre rula en PC con DX o OpenGl (win/linux), pero la verdad es que hay motores más "completos" y más fáciles de conseguir (y de usar) si lo que estás pensando es en hacer algo para PC.
Además Phyre esta optimizado para Cell y para utilizar las SPUs, y es donde le sacarás más partido (aunque solo sea para desmenuzarlo y cogerte lo que más te interese como manejo de jobs, código de SPU, etc.).
La compatibilidad con PC creo que realmente solo viene bien para las tools, y para previsualizar pequeños cambios (sobretodo afinación de gameplay y estas cosas) sin tener que estar mandando cosas al devKit (además chungo que todos los developers de una empresa tengan un devkit con lo "baratos" que son  ::)).

Si lo que quieres es hacer algo para PS3 tranqui que lo puedes tener nada más ingreses en la scedev(si tienes que hacer algo para ps3 tu empresa deberá estar registrada como desarrolladora autorizada) y te bajes todo el mogollonazo de gigas entre sdks y cosas.

No te puedo decir mucho más (NDA), pero yo que tú miraria otras opciones :)

Un saludo!

Hay cosas en youtube. Con tron tengo contacto (es colega) y curra en anima game. Con el otro ni idea.


http://www.youtube.com/watch?v=UyavaohQ7lA
http://www.youtube.com/watch?v=6N-1KeMl30o

Aqui Tron :P

El Retrik está practicamente muerto. Faltan graficos nuevos, el grafo esta en emme currando, no he acabado la version multiplayer y mi xbox tiene las tres p***s luces rojas.

Aparte ahora tengo bastante lio entre la Wii y la PSP.
De todas formas, quiero aprovechar para animar al resto de gente que sigue dandole caña al XNA,
Venga tios!!!


salu2 pa la penya!

Hola, gracias por contestar :)

Yo no guardo la matriz de transformacion en el mismo gameobject, sinó que lo he implementado en los nodos del scenegraph.

Asi es como lo tengo en la versión actual del "motor" (cada vez más risa esta palabra XD ) que corre ahora mi juego de puzzles en la xbox.
Pero realmente mi idea era sustituir el scenegraph "tradicional" por el entity manager y la transformación de los nodos del scenegraph por la clase esta llamada Transform que va asociada a cada entidad.

Si que tienes razón en cuanto al acoplamiento (aunque creo que tampoco tiene porque crearse mucha dependencia entre los componenetes, solo la que tu quieras darle, haciendo más componentes y pequeños o menos y grandes), de todas formas tampoco domino la "visión académica" del software, asi que si pudieras explicar los incovenientes que le ves seguramente me ahorrarias algún que otro susto :D
Por otro lado, como muy bien apuntas, la cohesión es de puta madre. Lo que para mi se traduce al final en una programación de gameplay mucho más sencilla y distribuida, además de por esa forma de hacer el "in-drive", que explican en el mismo articulo.
Además una de las cosas que me propuse conseguir era poder distribuir más adelante las tareas del motor entre los procesadores de la xbox, y la verdad es que me cuesta mucho pensar concurrentemente. Pero encontré unos ppt de una presentacion de la gdc2008 (Getting more from multicore, de Ian Lewis noseque de XNA Microsoft) con una explicación de tres tecnicas de ejecucion multiproceso (BSP, CSP y Task Pool), y la verdad es que intuyo más sencillo poder intentar hacer multi-thread en el motor con este tipo de patrón. (También lo he comparado con varios articulos de gamasutra sobre el mismo tema: engines con multi-threading)
Aunque, como he dicho, no tengo mucha idea del tema, y de momento tampoco estoy diseñandolo todo especifico para dividirlo en hilos.
¿Alguien con algo más de experiencia en multi-threading puede darme su opinión, plis? Gracias :)

Aunque, basicamente, mi pregunta anterior era más sobre el tema de la clase Transform que habia detallado, si la veiais útil (por la simplificación de la interfaz para acceder las coordenadas), o demasiado infeciente en algún sentido, si creeis que se podia mejorar, que opinais de mantener actualizada una matriz de mundo constantemente, etc.

Pues nada, gracias de nuevo por contestar :)
Dewwww!

Esta chulo :)
Yo también me tengo que poner con los modelos skinned en breve.

Por cierto, chula la interfaz de forms :D
A ver si le hago algo parecido al animador.

dew