SoloCodigo

Bueno este es uno de mis código antiguos para turbo pascal 7.
Si quieren tocar cualquiera de las 84 notas de un piano ojo va de [0..83]:
Nota: para afinar, cambien el 64 a un valor mayor o menor, como vean conveniente.

Lo de 2 elevado a nota/12 es cuestión de fijarse en las matemáticas simples de la música. son 12 tonos : 7notas + 5semitonos.

De hecho en todos los lenguajes que conozco se trabaja con radianes por que no necesitan "unidad". Un ángulo en radianes es un número y nada más.  

gracias me funciono disculpen si pregunto cosas tan si n chiste pero soy nueva programando en delphy

No te preocupes, pero tal vez colocando de título "importación de archivos" se podría ampliar el tema y abarcar también la importación de tipos de archivo estándar en general.

Maneje turbo Pascal hace como año y medio, y lo que pides, requerie de mucho trabajo, si piensas hacer algo asi, te recomiendo 2 opciones, VisualBasic (Facil de aprender) y C++ (Poderoso y respetable), aunque si escojes C++ y no estas familiarizado con el, te va a dar dolores de cabeza el entorno grafico (mejor usa Dev C++) y sobre Visual, bueno hay montones de paginas de codigos de ejemplos

Espero que esto te sirva de algo

El punto es que turbo Pascal v.? es un COMPILADOR antiguo a 16 bits. De todas formas lo recomendable sería Delphi v3 adelante (si sabes pascal no tendrás problemas con delphi), no es interpretado como VBasic y tienes todas las ventajas de los compiladores visuales de C++: POO e interfaz gráfica orienta a objetos, además de componentes listos para arrastrar y soltar.

En delphi podrás usar los tipos de datos base de C, incluso su forma de realizar comentarios, podrás usar varias formas de llamadas a funciones y procedimientos de forma optimizada (mediante registros) y otras formas compatibles con C.

Object Pascal, el lenguaje que utiliza el compilador delphi, refuerza la idea de orden y tipos fuertes. En C los tipos son débiles, lo que si bien permite escribir menos resulta en código difícil de comprender si no está generosamente comentado.

En Objetc Pascal tendrás que indicar claramente cuando usarás un entero como puntero o viceversa, cuando usarás un char como byte y viceversa, etc. El código generado será el mismo para ambos lenguajes con la diferencia que en Object Pascal es obligatorio incluir en el programa ese tipo de información, no para generar código, sino para hacer más legible el programa.

Yo hice un algoritmo de compresión mediante prefijos: La idea es recodificar cada byte en un prefijo único que puede tener n bits. Los bytes más frecuentes tendrán prefijos más cortos y los menos frecuentes prefijos más largos. No es necesario que cada nueva codificación tenga tamaño fijo por que son prefijos únicos y no existe ambiguedad al leerlos.

Al grano:

- Tienes que crear un funcion que almacene en un bloque de memoria n bits de por ejemplo un entero de 32bits, suponiendo que nunca tendrás un código de más de 32 bits. (más adelante lo detallo)

El problema es que sólo lo podrás leer secuencialmente, lo que no es problema para un algoritmo de compresión. Si necesitaras acceder en todo momento a cualquiera de los valores codificados y además necesitas saber la longitud en bits de cada código no te queda mejor remedio que desperdiciar bits y además agregar un byte extra para indicar el tamaño en bits del código:
un arreglo de int para el codigo (si no pasará de 32 bits) y otro de char para el tamaño.

Para almacenar códigos de n bits que sean prefijos únicos como usualmente ocurre en ese tipo de compresión (no sirve si es necesario saber la longitud de cada código de n bits):
==============================================0

Tienes que tener buffers de todo tamaño, en general:

1er buffer: un entero de 32 bits. (Registros)
2do buffer: un pedazo de memoria de digamos 64kb o lo que necesites o veas conveniente, si al final guardarás los datos en disco 64Kb no estarán nada mal (RAM)
3er buffer: si es necesario guardar en disco, un archivo abierto listo para guardar información. (DISCO)

La idea es esta:

- Coges el número entero y sabes cuantos bits tienes que extraer y almacenarlos en el buffer.
- Ves si en tu buffer de 32 bits existe espacio suficiente, si existe lo agregas usando desplazadores << >> para posicionar los bits en el lugar adecuado y los colocas con el operador de bits "or" |.
- Si no existe espacio suficiente tienes que partir en dos el código, guardar el pedazo que entra en el buffer y luego guardar el pequeño buffer de 32 bits en el buffer mayor, luego limpias el buffer de 32 bits y colocas el resto del código que faltaba colocar en buffer.

Lo mismo para los otros buffers:

Cuando se llene el buffer de 64 kb (ejemplo), guardarlo en disco y limpiar el buffer de 64Kb, luego agregar al buffer limpio lo que faltó guardar al momento que el buffer se llenó.

¿...existe un interés por obtener un ejemplo real, práctico y aplicado de estas fases en el desarrollo de un videojuego...?

Sin duda que será de interés para todo el que quiera programar un videojuego. No hay mejor forma de ver los posibles problemas y soluciones que se se puedan encontrar en el proceso de desarrollo del juego. Pero es mejor, si luego de terminar de desarrollar el juego, se hace un "ajuste" de los diagramas para que concuerden mejor con el resultado final en caso que hubieran sido necesarios dichos cambios. En ese caso no sólo serían los planos del proyecto de construcción, sino los planos reales.

la cosa es que recien empiezo con el tema de las listas enlazadas y se me pidio que calculara por ejemplo el termino nro 10.000 de serie de fibonacci y no tengo ni idea de como hacerlo, si alguien puede darme un indicio, desde ya gracias!!!

Es posible, no lo dudo, que tu catedrático sea tan... que no encontró otra forma de aplicar listas enlazadas (Que forma de complicar las cosas!!). Lo cual sería terriblemente lamentable. Si es el caso corresponde consultar directamente con google: listas enlazadas con o sin punteros es de lo más común que puedas encontrar, pero demasiado extenso para explicar en este foro a menos que sea un problema puntual.

Fibo Simple con recursividad:

f(1)=1
f(2)=1
...
f(n)=f(n-2)+f(n-1)

¿Que hay de complejo en esto? Si quieres optimizarlo creas una tabla con los primeros fibo y listo, cuando los necesites los lees de disco directamente a RAM y luego a utilizarlos tantas veces como quieras!!.

Bueno, queria saber si esto es legal

Supongamos que un amigo me pasa el 3ds Max Pirata y hago los modelos del juego ahi. Y luego me pasa el Photoshop y hago las texturas , osea en conclusion para acabar rapido, si utilizo puros programas pirateados para hacer mi juego y luego lo quiero vender a una compañia

¿Es ilegal vender el juego sin comprar las licencias del programa?

No se si me explique bien, pero es una duda, espero sus respuestas

Hmmm... sólo es legal si lo hace micro$oft o una compañía con suficientes abogados como para demostrar que es totalmente legal y demandar así a la compañía que se le ocurrío demantar a micro$oft.

Pero si trabajas a contrato para micro$oft, la compañia se queda con el producto y lo puede distribuir a quien se le de la gana y tu vas para prisión si cualquier parte del producto (hayas o no intervenido en su realización) fue hecho con un producto pirata, lo mismo ocurre si te atreves a demandar a una compañía que pirateó tu código fuente: tu vas para prisión y la compañia se queda con los derechos de autor.

RESUMEN:

NI SE TE OCURRA crear algún programa de ningún tipo que vaya a competir con algún tipo de producto de alguna multinacional, es ILEGAL y te aseguro que serás perseguido con TODO el rigor de la ley. Como todos sabemos la LEY protege a los grandes empresarios y asegura que no vayan a ser molestados por contaminar el medio ambiente, causar daños a los recien nacidos y/o esclavizarte hasta que termines muriendo por agotamiento, ya que estos y otros son derechos divinos inalienables del poder establecido.

1.- Yo use Turbo Pascal 6.algo y posteriores, no se si en el 5 las cosas eran muy distintas, cosa que dudo:


Básicamente este ejemplo, usando una hipotética funcion EsPrimo(), guarda en un archivo los números primos menores a 32000.

Si es posible, no siempre es el caso, te sugiero usar delphi, estos tiempos ya no están para volver a inventar la rueda.

opino que ya no es rentable realizar un juego 2D a gran escala (esperando que compita con un Quake, Doom, Unreal o equivalentes)

El tipo de juego tiene mucho que ver y los juegos que mencionas son definitivamente para 3D.

Ahora que para que un juego 2D sea rentable DEBE ser original para poder competir.

¿Se acuerdan de esos libros para hacer juegos en basic, para las amstrad, comodore, las antiguas IBM PC, etc?

Aún recuerdo como copiabas letra a letra, signo por signo el código fuente basic y luego te divertías muchísimo con esos juegos en modo texto de 40x25 caracteres o 80x25 en blanco y negro.  Sin duda eran juegos totalmente OPEN SOURCE. Yo tenía en esos tiempos una IBM modelo 25, una especie de XT, una disqueteras, bonita máquina, monitor de 12 o 10? pulgadas a color!.

Creo que sería bueno que los chicos de hoy tuvieran esas oportunidades...

Lo mejor es que busques un ejemplo simple OPEN SOURCE para el lenguaje de prog. que domines.

Es importante que el tamaño de tus tiles sean potencias de 2 (32x32, 64x32 y 32x16 son los más usados), en serio te ahorrarás problemas!. Aunque es posible que tus tiles tengan las dimensiones que te den la gana, a medida que avances en la creación del juego agradecerás que tengan tamaños "estándar".