Lenguajes de programación BASIC en PC: todo lo conocido

[jepalza]

¡Si señor, Macleod_Ideafix!, la demo del CPC6128.... (no es mia, sino que la convertí de los originales de las demos CPC que venían con el equipo)

[mcleod_ideafix]

Pues aquí va otro programa.

Este también es un port de uno que hice mientras aprendía C# y .NET . Aprovechando la coyuntura, lo he repasado y mejorado en algunas cosas. El código, viéndolos bis-a-bis, resulta un poco más críptico en FreeBASIC que en C#, fundamentalmente porque he comprobado que el compilador de FB no es nada bueno optimizando y he tenido que cambiar la forma en la que escribía el código añadiendo punteros y referencias a punteros cuando en principio no debería hacer falta. Es más, FB genera un código bastante feo y poco eficiente comparado con un compilador de C. Luego ahondaré sobre éstas y algunas otras cosillas que le he visto al FreeBASIC.

Pero lo cortés no quita lo valiente: es super sencillo hacer cositas con gráficos, sin comerse el tarro, como si estuvieras frente a tu micro de toda la vida.

El programa es un emulador.... pero no de un ordenador o de una videoconsola. Es un emulador... mejor dicho, simulador, de un universo. Con su Big Bang y todo. Es una prueba de concepto de un motor de partículas. Muestra una serie de ellas, sometidas a la ley de la gravedad (y ninguna ley más). Puede verse como después de la explosión inicial, el sistema evoluciona rapidamente formando estrellas y planetas que giran alrededor de las primeras en órbitas elipsiodales. Cuando dos astros chocan no rebotan, sino que el más masivo enguye al segundo y añade su masa y su momento lineal de forma que el sistema siempre conserva su momento lineal total (¡que es 0!).

Momento del Big Bang (pulsando S)


Hacia el centro de la pantalla (no es el centro exacto porque se generan pocas partículas y por tanto no es un sistema muy aleatorio que digamos) se situa una especie de diana rojiza que indica dónde está el centro de masas del sistema. Éste se sabe en el mismo momento en que se "crea" el universo. Si todas las partículas son engullidas y no se llegan a crear órbitas estables, el único astro que quede en pantalla deberá quedarse quieto en ese punto, con velocidad 0, para que se cumpla así el principio de conservación del momento lineal. Si el astro se mueve aunque sea lentamente, significa que en el sistema hay más partículas qe no han sido engullidas.

Durante la evolución del sistema puede observarse graficamente cómo se cumplen las leyes de Kepler. Por ejemplo, la tercera que dice que un astro que gira alrededor de otro barre áreas iguales en tiempos iguales. Esto significa que cuando el astro pequeño está cerca del grande, se mueve más rapidamente, y cuando está lejos, lentamente.

Dos astros orbitan alrededor de un tercero. Sus estelas indican la órbita de cada uno


Se pueden ver los vectores de velocidad de cada partícula (la tangente a la curva que describe el movimiento de la partícula en un punto) pulsando V. Pulsando E se muestra u oculta la estela verdosa animada que deja cada partícula y que permite ver la forma de su órbita. Pulsando C se centra la pantalla en la partícula de mayor masa (la que probablemente aglutine la mayor parte de la "acción" del sistema). La ayuda en pantalla se pone y quita pulsando T.

Si nos cansamos de ver un sistema, podemos hacer como un dios cualquiera y provocar un nuevo Big Bang pulsando S

Para aniquilar el universo y volver a Windows, pulsar ESC

El programa hace uso de la pantalla completa. Lo tengo probado en una pantalla a 1920x1080, pero debería acomodarse automáticamente a la resolución del escritorio que se tenga. Los colores están calculados para ser usados con RGB, no con paleta. No usa ni OpenGL ni nada por el estilo: cálculo puro.

Si al usar el programa veis que colapsa demasiado rapidamente y no llegan a verse órbitas estables, bajad el número de partículas (es posible que la pantalla sea más pequeña y no "quepan" todas ellas). Mirad en el código fuente, líneas 32 y siguientes, para ver dónde cambiar.

universo.bas

Código: Seleccionar todo

'Simulación de un sistema de particulas con masa
'sometidas a la ley de la gravedad.

'(C)2013 Miguel Angel Rodriguez Jodar
'Permitido su uso y distribucion bajo los
'términos de la licencia GPL

'Compilar con fbc -s gui universo.bas

#Include "fbgfx.bi"

Using fb

Type obj
   x As Double
   y As Double
   vx As Double
   vy As Double
   ax As Double
   ay As Double
   m As Double
   r As Double
   en As Byte
   estela(256,2) As Integer
   ultpos As Integer
End Type

Const G =    -0.001
Const PI =   3.141592654

Const frameskip = 64   'cada cuantos frames se redibuja la pantalla

Const N =    150    'número inicial de partículas
Const mmin = 20     'masa mínima de una partícula generada
Const mmax = 30     'mása máxima inicial de una partícula generada

Const tbigbang = 200  'tiempo en frames que dura la explosión del Big-Bang

Dim Shared univ(N) As obj
Dim Shared unext(N) As obj
Dim Shared mtotal As Double

Dim Shared As Byte ponestela, ponvector, pontexto
Dim Shared As Double dx,dy
Dim Shared tecla As String

Dim Shared As Integer xres,yres,bpp

Sub initworld (ByRef cx As Double, ByRef cy As Double)
   Dim As Integer i,j
   Dim As obj Ptr p

   mtotal = 0
   dx = 0
   dy = 0
   For i=0 To N-1
      p = @univ(i)
      p->m = mmin+(mmax-mmin)*Rnd
      p->r = Sqr(p->m/PI)
      p->x = xres*Rnd
      p->y = yres*Rnd
      cx += p->x * p->m
      cy += p->y * p->m
      p->vx = 0
      p->vy = 0
      p->ax = 0
      p->ay = 0
      p->en = 1
      p->ultpos = 0
      For j=0 To 255
         p->estela(j,0) = 0
         p->estela(j,1) = 0
      Next
      mtotal += p->m
   Next
   cx = cx / mtotal
   cy = cy / mtotal
End Sub

Sub makebigbang
   Dim i As Integer
   Dim As Double rx,ry,modulo,acel
   Dim As obj Ptr p

   For i=0 To N-1
      p = @univ(i)
      modulo = Sqr( (p->x-xres/2)*(p->x-xres/2) + (p->y-yres/2)*(p->y-yres/2) )
      rx = (p->x-xres/2)/modulo
      ry = (p->y-yres/2)/modulo
      acel = 2*modulo/(tbigbang*tbigbang)
      p->ax = -acel*rx
      p->ay = -acel*ry
      p->vx = acel*tbigbang*rx
      p->vy = acel*tbigbang*ry
      p->x = xres/2
      p->y = yres/2
   Next
End Sub

Sub muevebigbang
   Dim i As Integer
   Dim As obj Ptr p
      
   For i=0 To N-1
      p = @univ(i)
      p->vx += p->ax
      p->vy += p->ay
      p->x += p->vx
      p->y += p->vy      
   Next
End Sub

Sub calculadxdy (ByRef dx As Double, ByRef dy As Double)
   Dim As Integer i,cuenta
   Dim As Double mayor   
   
   mayor = 0
   cuenta = 0
   For i=0 To N-1
      If univ(i).en=1 Then
         cuenta += 1
         If univ(i).m>univ(mayor).m Then
            mayor = i
         EndIf
      EndIf
   Next
   dx = (xres/2) - univ(mayor).x
   dy = (yres/2) - univ(mayor).y
End Sub

Sub pintabola (img As Any Ptr, i As Integer, pintaestela As Byte, pintavector As Byte, dx As Double, dy As Double)
   Dim As Integer col,s
   Dim As UByte rojo,verde,azul
   Dim As obj Ptr p

   p = @univ(i)
   If pintaestela Then
      For s=0 To p->ultpos-1 Step 4
         PSet img, (dx+p->estela(s,0), dy+p->estela(s,1)), RGB(0,255-s,0)
      Next
   EndIf
   If p->ultpos<>0 Then
      For s = p->ultpos-1 To 0 Step -1
         p->estela((s+1) , 0) = p->estela(s,0)
         p->estela((s+1) , 1) = p->estela(s,1)
         If p->ultpos<256 Then
            p->ultpos += 1
         EndIf
      Next
   Else
      p->ultpos = 1
   EndIf
   p->estela(0,0) = p->x
   p->estela(0,1) = p->y

   rojo = 255
   If p->m < (mtotal/2) Then
      verde = 255
      azul = ((mtotal/2)-p->m)*255/(mtotal/2)
   Else
      verde = ((mtotal/2)-(p->m-mtotal/2))*255/(mtotal/2)
      azul = 0
   EndIf
   col = RGB(rojo,verde,azul)
   Circle img,(dx+p->x,dy+p->y),p->r,col,,,, F

   If pintavector Then
      Line img, (dx+p->x,dy+p->y)-Step (p->vx*500, p->vy*500), RGB(0,255,255)
   EndIf
End Sub

Sub showworld (pintatexto As Byte, cx As Double, cy As Double)
   Dim img As Any Ptr
   Dim As Integer i

   img = ImageCreate (xres,yres,RGB(0,0,32),32)

   For i=0 To xres Step 64
      Line img,(i,0)-(i,yres-1),RGB(0,0,64)
   Next
   For i=0 To yres Step 64
      Line img,(0,i)-(xres-1,i),RGB(0,0,64)
   Next

   For i=0 To N-1
      If univ(i).en=1 Then
         pintabola(img,i,ponestela,ponvector,dx,dy)
      EndIf
   Next
   
   If pintatexto Then
      Draw String img,(8,8),  "S: comenzar Big Bang. E: Mostrar/ocultar estela. V: Mostrar/ocultar vector velocidad."
      Draw String img,(8,16), "C: Centrar/no centrar en particular mayor. T: Mostrar/ocultar texto. ESC: Salir"
      Draw String img,(8,yres-16), "(C)2013 Miguel Angel Rodriguez Jodar ( mcleod_ideafix ). http://www.zxprojects.com",RGB(255,255,0)
   EndIf
   
   Line img,(dx+cx-64,dy+cy)-Step (128,0),RGB(32,0,0)
   Line img,(dx+cx,dy+cy-64)-Step (0,128),RGB(32,0,0)
   Circle img,(dx+cx,dy+cy),Sqr(mtotal/PI),RGB(64,0,0)
   
   ScreenSync
   Put (0,0),img,PSet
   ImageDestroy img
End Sub

Sub mueveworld
   Dim As Integer i,j
   Dim As Double modulo,rx,ry,na,dist,pm1,pm2
   Dim As obj Ptr p,q,r

   For i=0 To N-1
      p = @univ(i)
      r = @unext(i)
      unext(i) = univ(i)
      If p->en=1 Then
         r->ax = 0
         r->ay = 0
         For j=0 To N-1
            q = @univ(j)
            If i<>j And q->en=1 Then
               modulo = Sqr( (p->x-q->x)*(p->x-q->x) + (p->y-q->y)*(p->y-q->y) )
               rx = (p->x-q->x)/modulo
               ry = (p->y-q->y)/modulo
               na = G*q->m/(modulo*modulo)
               r->ax += na*rx
               r->ay += na*ry
            EndIf
         Next
         r->vx += r->ax
         r->vy += r->ay
         r->x += r->vx
         r->y += r->vy
      EndIf
   Next

   For i=0 To N-1
      p = @unext(i)
      If p->en=1 Then
         For j=i+1 To N-1
            q = @unext(j)
            If q->en=1 Then
               dist=Sqr( (p->x-q->x)*(p->x-q->x) + (p->y-q->y)*(p->y-q->y) )
               If dist<(p->r + q->r) Then
                  pm1 = p->m / (p->m + q->m)
                  pm2 = q->m / (p->m + q->m)
                  p->ax = pm1*p->ax + pm2*q->ax
                  p->ay = pm1*p->ay + pm2*q->ay
                  p->vx = pm1*p->vx + pm2*q->vx
                  p->vy = pm1*p->vy + pm2*q->vy
                  p->x = pm1*p->x + pm2*q->x
                  p->y = pm1*p->y + pm2*q->y
                  p->m += q->m
                  p->r = Sqr(p->m / PI)
                  q->en = 0
               EndIf
            EndIf
         Next
      EndIf
   Next

   For i=0 To N-1
      univ(i) = unext(i)
   Next
End Sub


Dim frames As Integer
Dim As Byte centraimagen
Dim As Double cx,cy

Randomize Timer
ScreenInfo xres,yres,bpp
ScreenRes xres,yres,bpp,,GFX_FULLSCREEN
SetMouse ,,0

frames = 0

ponestela = Not 0
ponvector = 0
centraimagen = 0
pontexto = Not 0

dx = 0
dy = 0
tecla = "s"

While tecla<>Chr$(27)
   If tecla="s" Then
      initworld(cx,cy)
      makebigbang
      frames = 0
      centraimagen = 0
   ElseIf tecla="e" Then      
      ponestela = Not ponestela
   ElseIf tecla="v" Then
      ponvector = Not ponvector
   ElseIf tecla="c" Then
      centraimagen = Not centraimagen
   ElseIf tecla="t" Then
      pontexto = Not pontexto
   EndIf

   If frames<tbigbang Then
      muevebigbang
   ElseIf frames>=(tbigbang+256) Then
      mueveworld
   EndIf
   If frames Mod frameskip = 0 Or frames<(tbigbang+256) Then
      If centraimagen Then
         calculadxdy (dx,dy)
      Else
         dx = 0
         dy = 0
      EndIf
      showworld(pontexto,cx,cy)
   EndIf
   frames += 1

   tecla = InKey
Wend
SetMouse ,,1

[Zardoz]

DIV
El "patito feo", tristemente, nos guste o no. Fué un proyecto desarrollado por "Hammer Technologies", Españoles (de hecho, así que yo conozca, el único Español 100%). El día que salió el "DIV GAMES STUDIO" en los kioskos, se agotó la primera edición. Todo el mundo quería hacer sus primeros juegos de modo simple y rápido. La primera versión (DIV a secas) era de MSDOS, poco despues sacaron DIV2, mejorado, con soporte para windows y comandos 3D.
Pero algo ocurrió, no entraré en detalles, y se suspendió el proyecto. Se llegaron ha hacer juegos comerciales con el DIV2, pero por lo que sea, se detuvo el proyecto y se dejó de vender.
La gente lo rescató años mas tarde, y en la comunidad libre lo relanzaron, añadiendo mas cosas, pero ningún proyecto llegó a término. Un día apareció FENIX, para sacarlo de las cenizas, tuvo mucha fuerza y seguidores, pero acabó igual, parado. Hoy día aún se sigue el proyecto, ahora llamado BENNU, pero a mi juicio, se ha perdido el espíritu del lenguaje DIV del que partió. Eso sí, es muy potente, y una muestra se puede ver AQUI

DIV no es BASIC... ni se le parece. Mas bien parece inspirado en el PASCAL en todo caso. (ejemplo: http://fenixdocs.com/index.php/Tutorial:Textinput)

Por cierto GAMBAS es un clon libre de Visual Basic (si queréis meter en el tintero que Visual Basic sea un BASIC)

[scooter]

Pues si, he hecho un par de cosas ahora en vb 2010 y tengo mis reservas de llamar a eso "basic"

[jepalza]

DIV no es BASIC... ni se le parece.

Si te lees las anteriores páginas del hilo, verás que ya se resolvió y explicó el porqué de incluirlo en la lista Basic, pero te resumo, que fué por añoranza, y por que, a mi juicio, "algo" de basic tiene, aunque solo sean "cuatro" comandos. (para gustos se hicieron los colores).

[mentalthink]

Hombre yo lo que creo que dentro de BASIC hablamos también de facilidad, tampoco hay que ponerse extricto, sobre lo del Visual Basic supongo que al ser algo similar al funcionamiento de Unity , o sea por objetos reales pones un botón y le meter el código, digo yo que lo decís por eso... en mi vida lo he tocado más allá de instarlo...

Sobre el Div, yo me lo compré y no sé si es porque no le puse mucha atención pero no entendia nada, también al ver las demos y ser jovencillo, no le ví una calidad demasiado interesante, sobre todo en el apartado 3D, aunque había un juego como un Street figther entre un esqueleto y un fortachón que no estaba demasiado mal la verdad, no sé si era 3D real, o como se dice, "pre.Renderizado"

[Zardoz]

Al hablar de Visual Basic, hay un antes y un después.
Los Visual Basic 6.0 y anteriores, se supone descendientes del BASIC Professional Development System desciende de un BASIC embebido para bases de datos y un generador de formularios, de hecho había aun versión para DOS del VB 1.0. Del 1.0 al 6.0 se podría medio defender como BASIC muy evolucionado, aunque para mi definición de BASIC, el QBASIC ya es el limite.

Las versiones posteriores al VB 6.0, los llamados Visual Basic .NET, rompe bastante con el lenguaje original, siendo más un híbrido del C# con el antiguo Visual Basic.

Respecto al tema de DIV/Fenix/Bennu, vale, no leí todos los posts
A todo esto... Un ejemplos modernos (y retro-remakes) hechos con Bennu (http://www.pixjuegos.com)

[na_th_an]

Hum - Eso pensaba yo (que el VB.NET había sido toda una ruptura) pero hace semanas me bajé el VB 2012, el que dan de gratis (¿Express?) y programé un poco y era prácticamente igual que VB6 - me refiero, seguía siendo la sintaxis de los MS Basic, pero totalmente orientado a objetos, sin permitir los híbridos que los VB <= 6 permitían. Vamos, que no tuve que aprender casi nada nuevo para hacer tres tonterías.

Inicialmente, el VBDos fue la versión siguiente al QBX de PDS 7.1. De hecho usaba exactamente la misma sintaxis y los mismos comandos, salvo por el tema de los formularios. De hecho, empleaba el mismo motor de threaded p-code que había empezado a usarse con la versión 4.0 de QuickBasic cuatro años atrás. Sin con el Basic embebido para aplicaciones y bases de datos te refieres al VBA, es algo posterior. Se deriva de VB5.0 y apareció por primera vez en la versión 5 de MS Excel.

Visual Basic comenzó de otra forma: básicamente, Microsoft buscaba un sistema para programar Windows 3.0 fácilmente, y contactó con la empresa de un tal Alan Cooper, que había desarrollado "Tripod", un sistema de ventanas basado en formularios. Microsoft creó entonces el proyecto Ruby basándose en Tripod, y añadió un compilador de Basic basado en la sintaxis de QuickBasic/PDS que empleaba Ruby como backend. Posteriormente realizó un port para MSDOS creando un manejador de ventanas basado en formularios basado en Ruby y empleando el compilador PDS.

[oscarbraindead]

Sobre el Div, yo me lo compré y no sé si es porque no le puse mucha atención pero no entendia nada, también al ver las demos y ser jovencillo, no le ví una calidad demasiado interesante, sobre todo en el apartado 3D, aunque había un juego como un Street figther entre un esqueleto y un fortachón que no estaba demasiado mal la verdad, no sé si era 3D real, o como se dice, "pre.Renderizado"

En mi opinión el DIV original y sus derivados (DIV2, Fénix, BennuGD, Gemix, etc) son la forma más sencilla de programar videojuegos. Es cierto que requiere cambiar un poco la mentalidad a la hora de programar (todo se hace en base a procesos concurrentes en lugar de código secuencial) pero, una vez asimilado cómo funciona, es sencillo y muy intuitivo.
Una pena que no esté más difundido.
Si queréis y os interesa, aunque no soy un máquina de esto, podría intentar hacer algún tutorial para dar unos primeros pasos con algún divlike... algo así como lo que han hecho los mojon twins con la churrera y sus tutoriales... aunque con menos nivel técnico-humorístico... uno dá de sí lo que dá de sí...

[Quest]

Curiosamente ayer probando la disketera de 5" 1/4 que conseguí en el mercadillo, con los disketes de 5" 1/4 que también conseguí en el mercadillo hace unas semanas, encontré unos cuantos disketes de alguna empresa de ingeniería donde tenían hechos programas de medición, diseño de estructuras, cálculo de frecuencias, etc, etc... hechos en GW-BASIC. Miles y miles de líneas de código BASIC en esos disketes... la mayoría de archivos tenían fechas de entre 1986 y 1989. Me resultó muy curioso encontrar todo eso, y a pesar de que al principio pensaba en formatearlos para usarlos en otras cosas, creo que algunos los voy a dejar intactos. Esos programas son personalizados, alguien picó el código en esa empresa...