Que tal, soy Pogacha.
Estoy buscando articulos o ejemplos de algoritmos de VIS / PVS o creacion del set de visualizacion potencial en un arbol BSP, el mejor de los modelos que he realizado demoran 30 minutos en el start-map del quake 1, me trepane el cerebro leyendo el codigo de J. Carmack ( Quien deberia abandonar el c y usar c++, ¿verdad?) y no lo entiendo. Los papers que he leido no son practicos. Si alguien sabe de algun lugar con info o ejemplos o lo que sea les agradeceria.
NOTA:
Hago el BSP, el CGS, Regionalizacion, Portalizacion, y el vis me esta demorando.

Saludos y gracias.

 El tema de las operaciones, si conte bien, son solamente un sqrt, un arcos, y dos pow por frame, eso se hacia en un spectrum, en un pc debe andar mas todavia.

Señor ABC7, creo que hay codigo para que te entretengas.

Saludos Pogacha

 Se me ocurre mas mejor:

Código [Seleccionar] Expand

real t = Tiempo_Del_Frame * Escala_De_Aceleracion;  // tiempo del frame en segundos

struct v { real x, y } // velocidad del personaje
struct p { real x, y } // posicion del personaje
real m; // modulo de velocidad

if(key[Arr]) v.y+=t;
if(key[Aba]) v.y-=t;
if(key[Izq]) v.x-=t;
if(key[Der]) v.x+=t;

m= sqrt(v.x*v.x + v.y*v.y);
if(m>Velocidad_Maxima)
{
  m=Velocidad_Maxima*Tiempo_Del_Frame/m;
  v.x*=m;
  v.y*=m;
}

Manejar_Colisiones_Colision(&p, &v) // en caso de colicion altera la velocidad, (deslizamiento o demas)

p.x+=v.x;
p.y+=v.y;

int x=Enterizar(p.x);
int y=Enterizar(p.y);

Dibujar_Bicho(x,y);

// aplico friccion, muy importante

real Friccion= 0.1

v.x*=Elevar(Friccion, Tiempo_Del_Frame);  // Friccion a la tiempo del frame
v.y*=Elevar(Friccion, Tiempo_Del_Frame);

De esta manera manejamos aceleracion del personaje y se movera mas lindamente.
Jugando con las constantes de aceleracion, friccion y velocidad maxima
vas a encontrar lo que buscas.

Despues faltaria ver la direccion en que se mueve para cada animacion y se me ocurre

Código [Seleccionar] Expand


real cosalpha = v.x / m;
real alpha = arccos(cosalpha);
if(v.y<0) alpha= - alpha;
int anim = Enterizar(alpha-(PI/8)) % 8;


y las animaciones correspondientes a cada velocidad serian:

3 2 1
4 X 0
5 6 7

Espero que te sirva.

Saludos
Pogacha

 Bien ... estuve pensando en el tema y concluyo:

Sobre el codigo original:
Bueno! (ole)
La idea es interesante, no se me ocurrio nunca la idea de una clase para
almacenar datos comprimidos (este tema se lo maneja mas en c y en la programación grafica y de juegos este tema es solo una herramienta, no un fin).

Al final todas las propuestas perdieron la glamorosidad que tenia el codigo original no?. Estaba muy elegantemente estructurado.

Seria bueno enumerar la lista de aplicaciones como para evaluarlo y entenderlo.

Por ahora solo se me ocurren estas:
Entrada de teclado o eventos del juego, para grabar un demo o algo asi.
Cierta información pesada sobre el mapa o personaje, por ejemplo, en el diablo II cuando salias de una pantalla los "bichos" volvian a aparecer como nada. En este caso el algoritmo de compresion debe ser otro, pero la base es la misma.


Sobre mi codigo:
Lo arme en una hora ...
No lo investiguen mucho, era para darle un vistaso nada mas.
Pero al poco tiempo se me ocurrio la idea que implemento Juan Mellado, que por cierto es mejor que el hashing o cualquier cosa de esas ( no tuve la vision para verlo en el momento ).
Sobre el factor de compresion, ni lo pense ... como era para notar la idea

El tema de las estructuras Bucket, Segmento o vectores paralellos:
Tienen una regla, si vas a pasar como argumento estos datos, metelos en una estructura o clase, pero si no, siempre convienen los vectores paralelos y pasar un indice (Afirma el ingeniero Hugo Reiquebuer).
En este caso todos los datos quedan dentro de la capsula, externamente no nos interesa como se repiten o no, por ende los vectores paralelos sobran, pero si los datos son complejos como en el codigo de Juan Mellado es preferible la estructura.

A fin de cuentas para mejorar la busqueda debes almacenar elementos repetidos y elementos que no se repiten y cuantos como datos.

Juan Mellado:
Segmento[i+1].Start==Segmento.End+1 ? Message("Segmento.End superfluo") : Message("No entendí");  ;)

Hace unos años se me ocurrio un metodo que usa este principio para mejorar la compresion RLE.

void Descomprimir(FILE *in, FILE *out)
{
 char c,d;
 while(!FEOF(in))
 {
     c=fgetc(in);  // cuantos
     if(c>0)  // se repiten
     {
        d=fgetc(in);  // que se repite
        while(c--) fputc(out,d);
     } else
     if(c<0)  // no se repiten
        while(c++) fputc(out,fgetc(in));
 }
}

Por sierto alguna busqueda binaria sin continue y sin recursion que alguien pueda aportar nos caeria bien y si alguien implemento una version final del ArregloRLE con STD seria bueno verla. O_O

Saludos
Pogacha.

 Yo hubiese hecho algo asi:


ArregloRLE.h

Código [Seleccionar] Expand


//----------------------------------------------------------------------------------------------
// Titulo: RLEManager? :P
// Autor: Carlos Campaña Molinero / MChiz
// Mail: MChis@ozu.es
// Fecha: 8 - 7 - 2003
//
// Version: 1.0
//----------------------------------------------------------------------------------------------
// Modificacion no autorizada
// Autor: Pogacha
// Mail: ferreyra@arnet.com.ar
// Fecha: 21 - 7 - 2003 - 12:30 a 2:10
//---------------------------------------------------------------------------------------------
#pragma once

#ifndef __ARREGLORLE_H__
#define __ARREGLORLE_H__

// #include <assert.h> // Sencillo y corto como patada de chancho
#define NULO (0)

template < class Tipo >
class ArregloRLE
{
 public:
 ArregloRLE( )
: _Datos( NULO )
, _Repetividad_Integrada( NULO )
, _n_Elementos( 0 )
, _n_Datos( 0 )
       {
       }

       ~ArregloRLE( )
       {
   if(_Datos) delete _Datos;
   if(_Repetividad_Integrada) delete _Repetividad_Integrada;
   _Datos=NULO;
          _Repetividad_Integrada=NULO;
   _n_Elementos=0;
    _n_Datos=0;
}

 void Adquirir( const Tipo *Arreglo, unsigned int n )
 {
               int i;
  unsigned int *Repetividad= new unsigned int[n];
  _n_Elementos = n;
  _n_Datos=0;
  for(i=0;i<_n_Elementos;i++) Repetividad[i]=0;
  i=0;
  while(++i < _n_Elementos)
  {
   Repetividad[_n_Datos]++;
   if(Arreglo[i-1]!=Arreglo[i]) _n_Datos++;
  }
  _Datos=new Tipo[++_n_Datos];
  _Repetividad_Integrada= new unsigned int[_n_Datos];

               _Repetividad_Integrada[0]=0;
  for(i=1; i<_n_Datos; i++)
       _Repetividad_Integrada[i]=Repetividad[i-1]
                                             +_Repetividad_Integrada[i-1];

        for(i=0; i<_n_Datos; i++)
       _Datos[i]=Arreglo[_Repetividad_Integrada[i]];

 delete Repetividad;
}

Tipo operator[](int i)
{
    int l,r,m;
    if((unsigned int)i>_n_Elementos) return Tipo(); // Lo que quieras no importa
     l=0;
    r=_n_Datos-1;

    do {
 m=(l+r)/2;
      if(i<_Repetividad_Integrada[m]) { r=m; continue; }  
// perdon por el continue
     if(i>=_Repetividad_Integrada[m+1]) { l=m+1; continue; }
               l=r;
    } while(l<r)
           return _Datos[m];
       }

       int n_Elementos()
// yo lo dejo como publico, pero si a ustedes les gusta asi
       {
           return _n_Elementos;
       }

 private:
Tipo *_Datos;
unsigned int *_Repetividad_Integrada;
unsigned int _n_Datos;
unsigned int _n_Elementos;
};

#endif


El main.cpp seria:

Código [Seleccionar] Expand


#include <stdio.h>
#include <conio.h>

#include "ArregloRLE.h"

void main( )
{
// Arreglo en crudo para comprimir
int ArregloCrudo[ ] =
{
 1, 10, 10, 10, 10, 10, 10, 5, 5, 5, 5, 23, 23, 23
};

// Creamos el ArregloRLE
ArregloRLE< int > ArregloComprimido;

// Adquirimos, o sea, comprimimos!
ArregloComprimido.Adquirir( ArregloCrudo,14);

printf( "\nArreglo comprimido con exito" );

// Imprimimos los valores de cada uno...
for(int i = 0; i < ArregloComprimido.n_Elementos( ); i++ )
 printf( "\nArreglo[ %d ]: %d", i,  ArregloComprimido[i] );

       printf("\nFactor de compresion:  %d : %d = %f",sizeof(ArregloCrudo),sizeof(ArregloComprimido),float(sizeof(ArregloCrudo))/float(sizeof(ArregloComprimido)));

// la descompresion se las dejo para luego, al igual que las tablas de hashing y toda esa onda.
       getch();
}

Si alguien no le gusta me cuenta.
Saludos Pogacha

                                Que tal, estoy desarrollando un editor de Niveles para juegos. Si te interesa, visita la pagina, descarga el editor, miralo y comentame.
http://www.gratisweb.com/bocacha/Santiago.html                                

                                La verdad es que si conoces el Arcanoid o el procesador intel pentium o el ab-shaper veras que no importe cuanto patentes, registres, o recursos legales tengas, no pasara un mes hasta que un oportunista probablemente chino o taiwanes(todo bien con los ponjas :D ), tome tu idea, la de vuelta, le cambie los colores, le añada canciones, y termine con moñito lista para la venta generandote un gran dolor de cabeza.
Si queres ganar dinero no lo pierdas con abogados, hacelo con un producto de calidad y si es tan novedoso tecnologico que les tome tiempo copiarlo mejor. Pero lo mejor es empezar a venderlo solamente, y registralo solo para que otro no diga que lo hizo él. No esperes que no te lo copien, por el contrario si así fuese deverias sentirte orgulloso.

Saludos
Pogacha                                

                                Señor Mellado:
Inpresionante!!!
Ni en un millon de años me hubiese dado cuenta!!!
Muy bien, muchas gracias!!, el asombro es descomunal.
Entonces habria que modificar el codigo(que por cierto es casi C y pensado muy pobremente, como diciendo "bueno, por ahora anda, despues lo arreglo") :-?.
Las funciones de conversion de numeros a caracteres utilizan la configuración regional. ¡¡¡Yo lo sabia!!!, inclusive hay funciones para conocer al punto o coma según la región y todo, pero ni me imagine todo eso.
Supuse que cuando compilabas ya quedaba sellado, y que como yo inponia el formato ¡listo!  :x .
Y como siempre la suposicion lleva al error!!!, mientras menos supones y estas mas seguro de lo que haces menos te equivocas.

Bueno, en argentina usamos la coma tambien, por lo menos en mi región, pero en la escuela tecnica nos enseñan todas las normas, como las unidades quimicas y fisicas, los formatos de normas desde las IRAM a las ISO, pero un cubano amigo dijo: "Argentina es la colonia Estadounidense mas grande que he visto en mi vida" y la mayoria adoptamos las SIMELA con los formatos Yankis, que resulta los mas facil y común.

Por otra parte refleja lo poco profecional del programa!!!

Saludos y muchas gracias!
Pogacha
Saludos                                

                                Por que puede ser que no carge en algunos ordenadores y en otros si, ahora necesito de un experto el codigo dice:

Abre con
...
f=fopen(Nombre.c_str(),"rt");
...

Nueva linea
...
t=fgets(Temp,255,f);
...

Pequeñas rutinas

int TScript::Clasificar(char c)
{
 if(isspace© || !c || c=='n' || c=='#') return 0;
 if(isalnum© || c=='-' || c=='.') return 1;
 return 2;
}

void TScript::Alimentar(void)
{
  if(!*t || *t=='n' || *t=='#')
    { Nueva_Linea(); } else t++;
}

char *TScript::Leer_Palabra(void)
{
 char *s=Salida;

 while(Clasificar(*t)==0) Alimentar();
 if(*t=='"')
 {
   do { Alimentar(); *s++ = *t; } while(*t!='"');
   s--;
 } else if(Clasificar(*t)==2)
 {
   *s++=*t; Alimentar();
 } else do { *s++ = *t; Alimentar(); } while(Clasificar(*t)==1);
 *s=0;
 return Salida;
}

Compilado con Builder C++ 4.0
¿Puede que esto cambie de ordenador a ordenador?

La verdad es que me parece bastante raro, si anda en todas las maquinas que yo tengo, quizas en europa n no sea fin de linea o no se alguna DLL, esto ya escapa de mis manos.

Haber quien se lo resuelve, el codigo fuente lo pondre mañana, junto al demo.

Saludos
Pogacha                                

                                Esta es la ultima version todo incluido editor y demo, las anteriores no existen mas.

http://www.gratisweb.com/bocacha/Demo.zip

Primero lo primero, se comanda con el raton, con ctrl apretado selecciona (importante las operaciones son para los seleccionados solamente) y con el boton derecho del mouse panea, delete borra, pgup/pgdn zoom,  Nuevo crea un solido, shift selecciona cara en modo Perspectiva Texturada.
Debes cargar la libreria de texturas, o crear una, solo acepta formato PCX, dice que tga pero es mentira :o .
La parte interesante para los programadores es la CGS, substraccion y ahuecación 8) .

Me llegaron mails en demanda del error del mapa, no es flor de mapa pero es de ejemplo nada mas, lo hice en cinco minutos, seguro que alguno de ustedes puede hacer alguno mejor. Bien, algo realmente interesante, desde mis ordenadores y los de mi facultad funciona sin ningun problema. Pueden hacer la prueba creando un micro mapa grabandolo y volviendolo a cargar y luego inevitablemente contarme que sucedio :ojo: .

Saludos
Pogacha[/url]                                

                               

Hola,
a mi al cargar el mapa me pone "DE_Dust3.MAP::Script_error:(2)Se esperaba numero de punto flotante" y al darle a aceptar sigue dando el error indefinidamente...

Bien, supuestamente si no modificaste el archivo DE_Dust3.MAP o esto no estuvo dañado no hay razon para que esto ocurra. Tengo una nueva version, e intentare subirla hoy mismo.
Quizas el formato de texto de tu ordenador...

El programa no esta completo de todas formas, la creacion del arbol BSP, el VIS, el CGS y LIT no estan incluidas por razones ovbias(que estan a medias y no llevan a ninguna parte, crean un formato que no puede ser leido por nada, solo un cuasi motor tambien a medias) , pero puedes utilizar las del quake o hl modificando el fichero MAP y bien, la idea es mas de hobbie que utilidad.

Sobre los que no pueden descargarlo, no se por que, quizas se pelearon los nodos :P , si me lo piden se los envio por mail, y todo no hay problema

Saludos
Pogacha                                

                                Desde mi maquina en Argentina logro descarlo con todo exito , pero si tienes interes te lo mando por mail (los dos archivos juntos tiene menos de 1 MB comprimidos en ZIP), es para win9x y es todo software asi que anda casi en cualquier cosa.
Si alguien mas no lo puede descargar hagamelo saber por favor.

Saludos.                                

                                Que tal, he desarrollado a medias un mapeador BSP, me gustaria, como el proyecto se cancelo por falta de merito de los principales organizadores, distribuirlo en forma de demo amistoso hogareño y que le sea de utilidad a alguien o bien continuar el proyecto con otra gente, funciona bastante bien pero no es compatible con los conocidos del HL o Quake III. Me gustaria que lo vieran y si les interesa el codigo fuente o preguntar por el mismo, podrian mandarme un mail, o demas.

El mapeador y demo se puede descargar de
http://www.gratisweb.com/bocacha/Demo.zip

Saludos
Pogacha                                

                                Pido permiso señores pero la custion son las directivas de enpaquetamiento y alineacion del compilador, pack byte, pack word, align .8, las cuales cambia en cada compilador.
Espero que este dato les sirva.