|
|
Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.
Mensajes - Amilius
Páginas: 1 ... 22 23 [24] 25 26 27
576
« en: Sábado 12 de Junio de 2004, 16:54 »
Ahi va un programa completo que hice hace bastante tiempo, espero que lo mejoren sustancialmente, corría en el TP7 para DOS.
577
« en: Viernes 11 de Junio de 2004, 18:55 »
Los Juego Via Internet, con la capacidad de jugar con muchos usuarios de todo el mundo es lo que sigue del 3D, o eso es a mi parecer, ya que la X-Box tiene esta capacidad, y conforme pasa el tiempo creo que dezplazara a lo juegos que no contengan este atributo.[/size] Tan cierto que no es necesario que sean 3d para tener éxito.
578
« en: Viernes 11 de Junio de 2004, 18:24 »
El original: (con algo más de precisión) gris = (unsigned char) (0.30*ROJO(pixel) + 0.59*VERDE(pixel) + 0.11*AZUL(pixel)); Es usado en los tv "blanco y negro", sistema que usan también los tv a color (separan la imagen en un canal de Y luminosidad y otros 2 sólo para el color UV.) Algun rato pongo las matrices para pasar a YUV y luego a RGB. Bueno, verifique que esto también va muy bien si quieres velocidad y no exactitud: (Además que no pierdes claridad): De más rápido a más lento (no pierden claridad): 1.- gris=(r+g<<1+b )>>2; Nota: El rojo es tomado como un color tan oscuro como el azul. Bastante rápido sin duda. 2.- gris=(r*3 + g<<2 + b ) >> 3 ; Nota: El rojo es tomado como un color mucho más brillante. (Buenos resultados para fotos de personas!) 3.- gris=(r*5 + g<<3 + b*3) >> 4; Nota: Este es intermedio entre 1 y 2, pero más lento OJO, como saben una multiplicación entera pesa en tiempo mucho menos cuantos menos bits tenga el multiplicador (una suma por cada bit en 1), habría que optimizarlo en ASM para asegurarse que los multiplicadores sean 5(2 bits en 1) y 3(2 bits en 1). Si el multiplicador sólo tiene 1 bit, se puede reemplazar por desplazamiento.  Y finalmente un truco para transparencia, alpha 50% extra rápida (se ve muy bien!) en 16 bits: (lo pongo para pascal, and es &, shr es >>) Mascara:=$F7DE;//sin los bits menos significativos. //el calculo se hará en 32 bits, por lo que no existirá desbordamiento. Pixel1 y 2 son enteros de 16 bits. Resultado:=((Pixel1 and Mascara)+(Pixel2 and Mascara)) shr 1;
579
« en: Viernes 11 de Junio de 2004, 16:51 »
Mira, no somos adivinos para conocer el formato o codificación del archivo binario que quieres interpretar.
580
« en: Jueves 10 de Junio de 2004, 19:47 »
Este juego es extremadamente simple de programar:
Se trata de adivinar el color de 4 fichas.
Elige color con los botones "O", haz click en la casilla
que pintarás (primero las de abajo y vas subiendo en
cada intento) y cuando formes un grupo de cuatro fichas
de colores presiona "Listo".
La idea del juego es adivinar el color de las cuatro fichas.
Si adivinas la posición exacta de una ficha, tienes un
punto negro.
Si adivinas el color de una ficha, pero no su posición
tienes un punto blanco.
581
« en: Jueves 10 de Junio de 2004, 19:31 »
Este juego es bastante sencillo y basado en el juego "Aventura" para gwbasic: Tienes una nave. Tienes que destruir a todos los invasores antes del tiempo límite. Puedes lanzar un rayo "destructor" o misiles. Puedes reparar tu nave y cargar nuevos misiles en las bases estelares. La diferencia es que el juego original era por turnos, y esta versíon no lo es, para darle más emoción al juego. P.D. Tal vez funcione con otras versiones de Delphi. Si no tienen el winrar, pueden bajarlo de: http://www.rarsoft.com/download.htm
582
« en: Martes 8 de Junio de 2004, 17:28 »
El operador in es para conjuntos, no para arreglos.
Por ejemplo: defines un conjunto de caracteres no válidos para el nombre de un archivo. Luego puedes revisar si un caracter está en el conjunto para desecharlo.
Si tu arreglo sólo consta de caracteres o todos sus elementos pueden ser enumerados podrás definir un conjunto y usar IN.
583
« en: Martes 8 de Junio de 2004, 06:12 »
Buenas
Tengo un problema, tengo 2 formularios
Bla bla bla bla bal
bla bla
bla  ¿Por que lo pusiste en el Create? void __fastcall TForm2::FormCreate(TObject *Sender) Esa ventana no se creará cada vez que presiones el otro botón, por que sólo se "mostrará" (según tu código), pero ya estará creada al principio. Por eso cambiar al valor de tu variable no pasara NADA.
584
« en: Domingo 6 de Junio de 2004, 04:56 »
Como nadie contesta...
Bueno, es muy probable que ya estés haciendo esto, pero de todos modos alla va:
1.- Tiles rectangulares de tamaño variable:
La idea es tener una aplicación auxiliar para "cortar" los gráficos del juego, de forma de evitar tener demasiadas partes transparentes. (ver gráfico adjuntado) También sería necesario una clase auxiliar que "encapsule" todo el lio de volver a armar el gráfico (ver la palmera adjuntada).
El objetivo es ahorrar memoria y al mismo tiempo evitar desperdiciar ciclos de cpu en zonas totalmente transparentes: En lugar de tener un gráfico sólido de la palmera con todas las partes en blanco desperdiciadas, se podría tener un conjunto de 3 a 6 (no demasiadas) regiones rectangulares de cada pedazo de la palmera.
Si los pedazos son demasiado chicos existe el peligro de perder todas las ventajas ganadas por que el peso del código adicional se haría sentir.
Si se dibuja y se tiene en memoria la palmera completa se desperdicia memoria y ciclos de cpu en zonas transparentes.
Para evitar complicar las cosas al momento de dibujar la palmera, tendría que existir algo de código de forma que sólo llamando a un método "dibujar" del objeto gráfico "palmera" se dibujen sus distintas partes.
Sería muy bueno que la aplicación auxiliar calculara la mejor forma de "partir" la imágen de forma de minimizar el áreas transparentes con un mínimo de áreas rectangulares.
585
« en: Domingo 6 de Junio de 2004, 04:21 »
¿Alquien ya trabajó con esta biblioteca de funciones open source para acelerar el alpha blending? http://sourceforge.net/projects/fblend/Básicamente está orientado a los que deseen realizar efectos especials en 15 ,16 y 32 bpp. Asegura ser de 2 a 14 veces más rápido que Allegro.
586
« en: Domingo 6 de Junio de 2004, 00:33 »
No sabía que existiera un método general para evitar todo tipo de recursividad.  ¿Y alguna vez usaste ese algoritmo general para evitar la recursividad?  ¿Que tan práctico es?  ¿En cuanto tiempo convertirías un ejemplo simple como las torres de Hanoi?  Voy a revisar algunos enlaces para ver que puedo aprender de ese método. 
587
« en: Sábado 5 de Junio de 2004, 22:55 »
Para imprimir texto en forma secuencial: writeln(lst,'texto'); Los caracteres especiales tienen efecto, por ejemplo: retorno de carro. Para imprimir gráficos:... Eso es complicado... no es como en windows... Esto sirve para imprimir texto en impresoras Epson lx-810, como la que tenía hace unos siglos: (Tienes que ordenar lo que estás imprimiento y recién en forma ordenada llamar a "imprime") Nota: los comandos de impresión están listados en el manual de la impresora, por lo que varían con el fabricante. unit impresor; interface Uses printer; var lineas_avanzadas:real; procedure inicializa(opc:byte); procedure imprime(x,y:real;cad:string); procedure finaliza; implementation procedure inicializa(opc:byte); begin write(lst,#27+'M'+#27+'x'); if opc=0 then write(lst,#0) else begin write(lst,#1); write(lst,#27+'k'+chr(opc-1)) end; lineas_avanzadas:=0; end; procedure imprime(x,y:real;cad:string); var a:word; x1,y1,y2:byte; spa:string; begin x:=x/2.54; y:=(y-0.8)/2.54-lineas_avanzadas; lineas_avanzadas:=lineas_avanzadas+y; y1:=round(y*216) div 216; y2:=round(y*216) mod 216; x1:=round(x*12); spa:=''; if y1<>0 then begin write(lst,#27+'3'+#216); for a:=1 to y1 do write(lst,#13,#10) end; write(lst,#27+'3'+#0); if y2<>0 then write(lst,#27+'J'+chr(y2)); for a:=1 to x1 do spa:=spa+' '; write(lst,spa); writeln(lst,cad); end; procedure finaliza; begin write(lst,#27+'x'+#0,#12) end; end.
588
« en: Sábado 5 de Junio de 2004, 02:39 »
ahi va uno no recursivo en ASM: const BitSuperior=$80000000; function SumaDesbordada(a,b:dword):longbool; // var bit_A,bit_B:dword; begin { result:=true; repeat if ((a or B) and bitSuperior)=0 then break;//no if ((a and B) and bitSuperior)<>0 then exit;//si a:=a shl 1;//siguiente bit superior b:=b shl 1; until (a or B)=0; result:=false;} { repeat bit_A:=a and BitSuperior; bit_B:=b and BitSuperior; a:=a shl 1; b:=b shl 1; until bit_A=bit_B; result:=(bit_A<>0);} asm //a está en eax //b está en edx //Bitsuperior=esi //bit_A=ecx //bit_B=ebx push ebx// preservar! push esi// preservar! mov esi,BitSuperior @ciclo: mov ecx,eax and ecx,esi mov ebx,edx and ebx,esi shl eax,1 shl edx,1 xor ebx,ecx//cmp hace una resta :P jnz @ciclo pop esi pop ebx mov result,ecx//prácticamente igual a mov eax,ecx end; end;
Ya veo el problema: Esto no funciona (el flag de overflow, ni el de carry) para a y b como enteros de 32bits SIN signo: //Sólo para a y b enteros 32bits con signo asm //a está en eax //b está en edx xor ecx,ecx//ecx=false add eax,edx//sumar jno @fin//saltar si no existe overflow not ecx//ecx=true @fin: mov result,ecx end;
589
« en: Viernes 4 de Junio de 2004, 17:33 »
Juegos puedes programar en el lenguaje que quieras, todo depende del nivel técnico que quieras alcanzar en lo que se refiere a gráficos y sonido.
DirectX es popular por que facilita la programación de juegos comerciales, especialmente la parte 3D, en 2D su aporte es modesto (2d no es comercial), pero te deja libertad para optimizar tus algoritmos. Pero en el sentido de facilitar las cosas para 3d OpenGl es mucho mejor que DirectX.
C++ es el lenguaje más extendido en el mundo comercial y por esto es más fácil encontrar ejemplos en C++. Pero el problema es que tendrías que tener un buen nivel en C++ para no terminar frustrando tus espectativas al momento de programar un juego. OJO que las grandes empresas tienen cientos de herramientas listas (clases, funciones, herramientas para los gráficos, sonidos, etc) para no tener que lidiar con detalles de programación tediosos y dedicarse directamente a la esencia del juego.
Sólo ten en cuenta que una cosa es dedicarte profesionalmente a hacer juegos (tendrías que conseguir empleo en una empresa del ramo) o hacerlos en forma independiente como afición/pasatiempo. ¿Cual es tu caso?
590
« en: Jueves 3 de Junio de 2004, 18:59 »
Es la misma librería CRT, conseguí el código fuente y sólo reprogramé la función del delay ( usando directamente una función del bios) para que no se necesitara calcular al inicio el número de ciclos de espera.
591
« en: Jueves 3 de Junio de 2004, 05:10 »
Este es el post:
"Biblioteca De Funciones"
Para Turbo Pascal v 7
En el archivo .zip está incluida una librería .tpu "crtZ.tpu" junto con los códigos fuentes en ASM.
Para usar el "crtZ.tpu" basta copiarlo a la carpeta units, o a la carpeta donde están tus ".pas". En el uses en lugar de poner crt colocas crtz.
El crtz básicamente es exactamente igual al crt normal, excepto que no tiene el bug de "división entre cero", que en realidad es causado por el algoritmo que calcula el número de ciclos de espera para el "delay". Como las máquinas actuales son mucho más rápidas, el número de ciclos de espera necesarios es tan elevado que supera el límite máximo de un entero de 2 bytes y da error de desbordamiento (que también es causado por una división entre 0, por eso el mensaje).
592
« en: Jueves 3 de Junio de 2004, 04:18 »
Aqui va el código fuente del random para enteros que usa delphi, tal vez sea de utilidad para alguien:
Para el caso práctico RandSeed es una "variable global", se la inicializa con el método del timer que expuso deldar: (Ojo es para 32bits)
procedure _RandInt;
asm
{ ->EAX Rango } // el resultado va de 0 a EAX-1
{ <-EAX Result }
IMUL EDX,RandSeed,08088405H
INC EDX
MOV RandSeed,EDX
MUL EDX
MOV EAX,EDX
end;
593
« en: Lunes 31 de Mayo de 2004, 19:49 »
En realidad, fue algo que mi profesor de la universidad me dijo, que remover la recursión es complicado pero una vez hecha ésta, la versión del algoritmo es siempre más eficiente. Ya me lo imaginaba... El problema es que existen otras prioridades: Aumentar funcionalidades, mejorar la estética, etc. Muy poco tiempo=dinero para optimizaciones que además pueden causar futuros bugs=perdidas. Te aseguro que en el mundo real jamás optimizarás algo hecho recursivamente A MENOS que sea del tipo simple: << Si sólo existe una llamada recursiva al final de la función recursiva. >> Sólo en ese caso se las pueden convertir en simples ciclos. Los otros casos no son fáciles de programar sin recursividad (Tienes que programar la pila personalmente  ) En el mundo real a nadie se le ocurrirá optimizar de esa forma ¿Que ganarás, un 3% más de velocidad.. unos cuantos kbytes menos de consumo de RAM?. Tendría que ser un algoritmo realmente y brutalmente crítico. Sólo optimizen código si el usuario SENTIRA una GRAN MEJORA, o estarán perdiendo tiempo/dinero. Respecto a desbordar la pila: Siempre que se haga más de una llamada recursiva dentro de la función teniendo cuidado de definir el punto muerto de la recursividad no tendrás que preocuparte por desbordar la pila: 1.- El consumo de ram de tus parámetros por lo general no pasará de un puñado de bytes. 2.- Número de niveles de recursividad, digamos 100, implica procesar la función para digamos 2 llamadas recursivas dentro de la función= 2^100 (eso es bastante tiempo ), y si multiplicas digamos unos 32 bytes de parámetros por 100 niveles te dan algo de 3kb de RAM. Además dudo que se pasen de 20 niveles de recursividad salvo excepciones muy pero muy raras. "la versión del algoritmo es siempre más eficiente" ¿Seguro que no se refería sólo a los casos simples que se pueden programar con un ciclo? Tu profe no penso mucho para decir eso... - SIEMPRE ??? Y que pasa si es un programador novato? - Tienes que tener elevado nivel de programación para hacerlo más eficiente que el compilador y repito de LA CALIDAD DEL COMPILADOR resultará código más rápido o más lento. - En la mayoría de los casos bastará pensar bien los tipos de los parámetros que pasarás y ahorrarte cada byte que puedas.
594
« en: Lunes 31 de Mayo de 2004, 19:15 »
Private Function Desplazar(Valor As Integer, Direccion As String, nBits As Integer) As Integer Dim i As Integer If Not 0 < nBits < 16 Then Err.Raise 1001, , "Número de bits a desplazar incorrecto" Desplazar = Valor If Direccion = "izq" Then 'Desplazamiento a la izquierda For i = 1 To nBits Desplazar = Desplazar * 2 Next i ElseIf Direccion = "dch" Then 'Desplazamiento a la derecha For i = 1 To nBits Desplazar = Desplazar \ 2 Next i End If End Function
NOOOOOOOOOOOOO!!! La complejidad de realizar un desplazamiento con ASM es 1. (C y Pascal tienen funciones (<<,>>;shl,shr) que hacen lo mismo que en ASM, no recuerdo en VB pero fija que debe tener) Complejidad de realizar una multiplicación: 17 en promedio para 32 bits. Para división es algo mayor. (Multiplicación usa desplazamientos y sumas, prácticamente un desplazamiento y suma por cada bit 1 del número) La complejidad de desplazar usando multiplicaciones: 17*promedio de bits desplazados. digamos 8, entonces = 136. Por lo tanto tu código es POR LO MENOS en promedio 136 veces más lento de lo que debería ser, sin contar otros detalles mayores!!. (Usas un montón de cosas sólo para hacer algo que viene ya incluido en todo procesador, en realidad es posible que el código sea tranquilamente hasta 400 veces más lento de lo que debería ser)
595
« en: Lunes 31 de Mayo de 2004, 19:05 »
Oo Vaya que te esfuerzas en escribir preguntas claras...  El "maravilloso" visual C++, en manos equivocadas capaz de convertir el más simple de los problemas en toda una pesadilla.... ¿Realmente creen que un programador novato podrá crear un programa eficiente en memória y cpu, sin contar con los bugs, sólo por usar el "visual C++"? El C++ no es para aprender programación, a menos que seas un sádico para enseñarlo a principiantes de programación. Pero el mundo está lleno de sádicos y masoquistas.
596
« en: Lunes 31 de Mayo de 2004, 18:54 »
Eso es simplemente ridículo. Un programador inexperto/desordenado siempre hará estragos usando cualquier técnica/lenguaje/compilador por muy buenos que sean.
597
« en: Lunes 31 de Mayo de 2004, 07:19 »
hmmm... Ya veo.
Es probable que el Insight definitivamente fué programado y verificado sólo con matricies estilo C, que siempre comienzan de 0 y por eso que da problemas cuando la matriz aparentemente comienza de 1: Internamente comienza de 0 (lo que explica que la fila 2 no existe), pero luego erroneamente anula la posición 0, (en ese caso considera que se comienza por 1) y el resultado es tener la fila 0 toda vacía.
598
« en: Lunes 31 de Mayo de 2004, 06:54 »
Bajate la libreria de funciones que puse en el otro post, tiene una versión de crt crtz corregida, la explicación está en otro post (en realidad no es una división entre 0 sino desbordamiento por la velocidad de las máquinas actuales ). 
599
« en: Lunes 31 de Mayo de 2004, 05:21 »
Simple: (Recursivo) Pasas todos menos el último al auxiliar, luego el último al destino y todos los que faltan al destino.
Para que pasen todos por el auxilar primero pasa todos al auxiliar y luego todos al destino final.
600
« en: Domingo 30 de Mayo de 2004, 23:14 »
Mejor si colocas al form en propiedades keypreview=true y usas los eventos:
OnKeyDown, OnKeyPress , Onkeyup, etc.
Puede ser un poco desorientador trabajar con una interfaz orientada a eventos si usaste antes Pascal en compiladores antiguos, pero ya te acostumbrarás y verás las ventajas.
Otra opción, un tanto no recomendable, es tener un ciclo y revisar el estado de las teclas con:
GetKeyState(VkKeyScan('a'))
Y no te olvides de incluir en el ciclo el "application.ProcessMessages;" o se quedará todo "trabado".
---------------
The GetKeyState function retrieves the status of the specified virtual key. The status specifies whether the key is up, down, or toggled (on, off ¾ alternating each time the key is pressed).
SHORT GetKeyState(
int nVirtKey // virtual-key code
);
Return Value
If the function succeeds, the return value specifies the status of the given virtual key. If the high-order bit is 1, the key is down; otherwise, it is up. If the low-order bit is 1, the key is toggled. A key, such as the CAPS LOCK key, is toggled if it is turned on. The key is off and untoggled if the low-order bit is 0. A toggle key's indicator light (if any) on the keyboard will be on when the key is toggled, and off when the key is untoggled.
----------
The VkKeyScan function translates a character to the corresponding virtual-key code and shift state for the current keyboard.
SHORT VkKeyScan(
TCHAR ch // character to translate
);
Páginas: 1 ... 22 23 [24] 25 26 27
|
|
|
Mostrar Mensajes
