[Brico-Scene] UltraStar (Clon de SingStar)

Archivado
1, 2, 3, 4
Imagen
Imagen en formato SVG


Proyecto en standby. Abierto ideas y sugerencias para reemprenderlo cuando se pueda

------------------------------------------------------------------------

Los que queráis participar en el proyecto avisad en el hilo y crearos una cuenta en assembla que es donde vamos a trabajar en común. En cuanto os hayáis creado un usuario os vincularemos al grupo.

Y puesto que ya disponemos de base en C++ cito a gobo26

gobo26 escribió:Una vez que el juego portado funcione en PC simplemente habria que pelearse con la parte opengl, con el analisis de la voz y con detalles especificos del C que pueden ir surgiendo.


Si quereís estar al día de las acutalizaciones, usad nuestro SVN:

https://ultrastarwii.svn.sourceforge.net/svnroot/ultrastarwii
http://svn.assembla.com/svn/ultrastarwii/trunk

Trac:

http://trac.assembla.com/ultrastarwii/browser


------------------------------------------------------------------------


Vale, como antes de nada hay que presentar el juego original, ahí van un par de capturas del mismo.

Imagen Imagen

¿A qué da el pego como si se tratase del SingStar de Sony? Pues bien, resulta que las pantallas de arriba pertenecen a UltraStar, ése juego que todo ser humano con novia, hermana, complejo de tiunfito o mero afán por hacer el chorra un rato delante de la consola ansía desde el mismo momento en el que la apañada última consola de Nintendo se hizo un hueco bajo la tele*. En resumidas cuentas un logradísimo clon opensource.

(*): Caso genérico, puede no coincidir con la realidad.

¿Y qué pinta un hilo del Ultrastar? ¿Ha salido, va a salir para wii dentro de poco? A ver de qué va esto...

Respondiendo antes a la segunda cuestión: Me da a mí que no.
Ahora la respuesta a la primera pregunta:

A raíz del hilo de ramulator en el que preguntaba por cómo se realizan los ports de PC a Wii, nos hemos calentado y queremos meterle mano a una aplicación de código libre que aún no hubiese sido portada a Wii para ser nosotros los eolianos quienes nos la traigamos a la blanquita. El juego de karaoke presenta un gran aliciente para que nos pongamos manos a la obra aunque eso implique ir aprendiendo sobre la marcha.

Todo el que pueda echar un cable, bienvenido será. Y para desanimar a los débiles de espíritus doy paso al siguiente titular.

Los hándicaps:
- Creo que no existe información referente al reconocimiento de la señal de audio (lo cual implica que no hay librerías).
- El código fuente de la aplicación original en la que nos basaremos es Pascal orientado a objetos. (Solventado: Ultrastar NG)
- El apartado gráfico se sustenta en OpenGL, librerías de las que no disponemos (reescibir usando GX).
- Algunos nombres de funciones y variables están escritos en polaco xD

Frentes de trabajo

- Reescritura de openGL a GX
- Adaptación para el wiimote
- Investigación del uso del micrófono
- La lectura de las canciones a través de la SD
- Adaptar un visualizador de vídeos MPG

Porteos de librerías (considerándose)

ORIGINAL____________________________________________REEMPLAZO

SDL ------------------------------------------------------------- SDL-Wii (?)
Cairo ------------------------------------------------------------ libpng (?)
Alsa ------------------------------------------------------------- ?????
libxml ----------------------------------------------------------- xml de libogc (?)
boost ------------------------------------------------------------ mutex.h
Pango fonts ---------------------------------------------------- ?????
OpenGL --------------------------------------------------------- gl2gx


*****************************************************

Descargas

svn co https://ultrastar-ng.svn.sourceforge.ne ... trastar-ng ultrastar-ng

Ultrastar Next Generation - CVS browser en SourceForge

Imagen
Tema lima con pantallas en formato SVG

Pienso que hasta que consigamos que esto empiece a avanzar no deberíamos movernos al foro de desarrollo, ya que ahora mismo no deja de ser un simple llamamiento a la colaboración.

Los principales objetivos no son más que la unión de la peña y el afán didáctico. Conseguir el port sería un premio y reconocimiento a que hubiésemos conseguido hacer las cosas bien.
Piano, piano. Hoy por hoy no hay prisa ninguna; entre otras razones porque aunque se avanzase pronto con el código, nos seguiría faltando quien trastease con los micros. Y porque algunos empezamos a estar mayores como para asimilar conocimientos si no nos lo empezamos a encontrar casi todo mascadito...

Ánimo a todos, cualquier aporte va a ser de gran importancia, sea cual sea su magnitud.

Y si se me olvida algo ya editaré o postearé después.

Saludos.

***********************************************

Documentación:

- USB and PIC Microprocessors 16C745 and 18F2455
- Graficos 3D para Wii (PDF + Ejemplos) por Hermes
- Boost -Getting Started on Unix Variants
- Cairo - Tutorial
- Scalable Vector Graphics (Wikipedia)
- FMOD Sound Library
- Pango_fonts

***********************************************

Instalación de TortoiseSVN para acceder a assembla:

Para quienes no tengan claro como trabajar en un SVN, en el caso de que utilicen Windows pueden utilizar TortoiseSVN para trabajar con él sin apenas complicación.
Esto es sólo orientativo pero os facilitará el camino a los recién llegados.

Como primer paso, localizad TortoiseSVN y realizad la instalación por defecto: "Siguiente", "siguiente", "siguiente"... Una vez que haya finalizado os pedirá reiniciar el PC. Aceptad y acercaros al frigo a echar un vistazo o simplemente incorporaros de la silla para estirar piernas que nunca viene mal.

Imagen

Cuando hayamos regresado a Windows ya se habrá integrado el programa correctamente en el shell, lo que viene a ser que cuando utilicemos el botón derecho del ratón sobre una carpeta o directorio tendremos disponibles nuevas opciones para gestionar nuestro contenido local en vinculación con un espacio SVN.

Lo siguiente que habrá que hacer es una carpeta donde volcaremos el contenido del SVN quedando asociado a éste. Por tanto: se crea una carpeta y en el menú contextual que se muestra al pulsar el botón derecho seleccionamos "SVN Checkout".

Imagen

Tenemos que indicar http://svn.assembla.com/svn/ultrastarwii/trunk en la URL del repositorio. Le damos a "OK" y nos logeamos con los datos de la cuenta en assembla. Ahora esperamos a que se descargue el contenido del SVN.

Imagen
Que no os confunda la imagen, únicamente pretende mostrar el diálogo de login

Imagen

Ya podéis examinar el contenido de la carpeta que se corresponderá con lo que en el momento del "checkout" hubiese en el servido. Y a partir de ahí, a trastear con el código y con las opciones del tortoise.

Imagen
Otia que chulada :O yo, como muchos de los que escribirán detras de mi, no puedo aportar nada porque soy tonto xDDDD, pero os animo a todos los que querais trabajar en este proyecto, siempre me pareció muy chulo el jueguito xDD

Con el tema del programa no podré ayudar, pero si esto llega a buen puerto, si que me animaria a montar karaokes y demás ^^ xDD

Un saludo!
yo quiero ayudar, pero tengo que aprender
ultrastar eol
el mejor XD
yo se pascal (salvo punteros) me falta aprender C y puedo ir traduciendo cosillas...
Si está en Pascal orientado a objetos lo normal seria portarlo a C++ no?

Yo nunca he visto Pascal, pero sé C y C++, miraré a ver si entiendo algo y puedo portear algo...
Pos yo me apunto como ya sabe realbrucest. Asi que luego miro cuales cojo y palante.
Existe Ultrastar Nex Generation que es un port del ultrastar a c++ para linux:
http://sourceforge.net/projects/ultrastar-ng/
EDIT: Me he informado mejor, parece ser que más que un port, lo han reescrito completamente y, la verdad tiene peor aspecto: http://linux.softpedia.com/progScreensh ... 23084.html
De todas maneras me encantaría ayudaros pero no se pascal
Entonces, con esto y Wii Linux, esto iria más rápido, no? :o aunque aun queda pendiente el tema del micrófono
¿Las gl2gx 1.2 no os sirven?
http://code.google.com/p/gl2gx/downloads/list
Pues como han dicho, puestos a portar una versión, mejor el NG que ya está en C++.
Pero veremos a ver como sale...
Oid... ¿No creeis que sería mucho mejor diseñar un SingWiiStar ( [sonrisa] ) propio, en vez de andar portando cosas?

La mayor complicación del juego es, a mi juicio, crear las rutinas de reconocimiento de voz. O sea, realizar un analisis de fourier de la señal de entrada. Yo creo que eso se podría hacer buscando alguna rutina de las GSL (GNU scientific libraries) que sirva y adaptarla.

Por supuesto que puede uno inspirarse en este juego hecho en pascal, pero creo que se obtendría una mayor calidad y claridad en el codigo si se empieza desde 0.

Por cierto... ¿Hay micrófono para Wii? :-?
Moki_X escribió:Oid... ¿No creeis que sería mucho mejor diseñar un SingWiiStar ( [sonrisa] ) propio, en vez de andar portando cosas?

La mayor complicación del juego es, a mi juicio, crear las rutinas de reconocimiento de voz. O sea, realizar un analisis de fourier de la señal de entrada. Yo creo que eso se podría hacer buscando alguna rutina de las GSL (GNU scientific libraries) que sirva y adaptarla.

Por supuesto que puede uno inspirarse en este juego hecho en pascal, pero creo que se obtendría una mayor calidad y claridad en el codigo si se empieza desde 0.

Por cierto... ¿Hay micrófono para Wii? :-?

Moki_X no nos pongas a dudar ahora que ya lo hemos cogido con ganas :P

Portear directamente, aunque en nuestro caso implique la traslación del código a otro lenguaje nos evita tener que pararnos a pensar en cómo tendrá que ser la lógica del programa. No veo necesidad de rediseñar el juego si ya disponemos de los fuentes de uno que es un calco del SingStar comercial. Ahora bien, es sólo mi punto de vista que tampoco es que entienda demasiado de proyectos relativamente grandes.

Micrófono tenemos los del Boogie de EA (que digo yo que alguien lo habrá debido de comprar), también alguno genérico venden por ahí y acabo de descubrir tras un rápido googleo que el High School Musical es otro juego que lo trae.

En resumidas cuentas, volviendo a lo de antes, es que dedicándonos al porteo "a lo bruto" habrá peña con conocimientos más limitados o que no tienen tiempo o ganas de comerse la cabeza demasiado que no tendrán demasiados problemas para poder contribuir en la medida de sus posibilidades. Trabajar desde cero restringe más el desarrollo.
En cuanto consigamos el Ultrastar Wii, ya para la siguiente aplicación, si seguimos con ganas, ya nos inventaremos algo original.

Y como me autoincluyo en el grupo de noobs voluntariosos anteriormente descrito, dejo el código en C++ de uno de los archivos pequeños para que el que pueda le eche un vistazo por encima, me avise de las meteduras de pata graves y no tan graves, y sugiera qué metodología/forma de estructurar el código cree más conveniente.
(Importante esto último ya que tendremos que poner todo en común, para volver a ensamblar todo en un proyecto).
Por supuesto, aspiro a aprender y comprender el código del juego de pe a pa.

/***************************************************************************************
Language

- TODO:
 
  - Sustituir los operadores de concatenación de cadenas +

***************************************************************************************/


/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  TLANGUAGEENTRY
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

struct TLanguageEntry
{

    char*   ID;

    char*   Text;

}


/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  TLANGUAGELIST
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

struct TLanguageList
{

    char*   Name;

    //char*   FileName;

}


/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  TLANGUAGE
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

class  TLanguage
{

    public

      struct TLanguageList* structList;

      struct TLanguageEntry* Entry;

      void TLanguage;

      void LoadList;

      char* Translate(char* Text);

      void ChangeLanguage(char*Language); // loads Polish, English and then selected language

      void LoadLanguage(char* Language); // loads only one language

      void AddTranslation(char* ID, char* Text); // adds (replaces if needed) one translation item

}



TLanguage Language;



/*uses UPliki, UIni, IniFiles, Classes, SysUtils, Windows, ULog;*/

//--------------------------------------------------------------------------------
//
// CONSTRUCTOR TLANGUAGE
//
//--------------------------------------------------------------------------------

void TLanguage::TLanguage()
{

  //Variables

  TSysLocale SysLocale;

  //Inicio

  LoadList();



  //  if GetOEMCP = 852 then

  SysLocale.PriLangID;



  //  if L = chr($415) then

  //  ChangeLanguage('Polish')

  //  else}

  //  ChangeLanguage(ILanguage[Ini.Language]);

  //  ChangeLanguage('English');


}//end constructor


//--------------------------------------------------------------------------------
//
// LOADLIST
//
//--------------------------------------------------------------------------------

void TLanguage::LoadList(void)
{
  //Variables

  TSearchRec   SR;   // for parsing directory


  //Inicio

  SetLength(List, 0);

  SetLength(ILanguage, 0);



  if (FindFirst(LanguagesPath + "*.ini", 0, SR) == 0 )
  {

    do
    {

      SetLength(List, Length(List)+1);

      SetLength(ILanguage, Length(ILanguage)+1);

      SR.Name = ChangeFileExt(SR.Name, '');



      List[High(List)].Name = SR.Name;

      ILanguage[High(ILanguage)] = SR.Name;



    }while(FindNext(SR));


  //FindClose(SR);

  }//end if FindFirst


}//end LoadList


//--------------------------------------------------------------------------------
//
// CHANGELANGUAGE
//
//--------------------------------------------------------------------------------

void TLanguage::ChangeLanguage(char* Language)
{

  //Variables

  TIniFile   IniFile;

  u16      E; // entry

  TStringList   S;


  //Inicio

  SetLength(Entry, 0);

  LoadLanguage("Polish");

  LoadLanguage("English");

  LoadLanguage(Language);


}


//--------------------------------------------------------------------------------
//
// LOADLANGUAGE
//
//--------------------------------------------------------------------------------

void TLanguage::LoadLanguage(char* Language)
{

  //Variables

  TIniFile   IniFile;

  u16      E; // entry

  TStringList   S;


  //Incio

  IniFile = TIniFile.Create(LanguagesPath + Language + ".ini");

  S = TStringList.Create;



  AddTranslation("US_VERSION", "UltraStar 0.5.3");



  IniFile.ReadSectionValues("Text", S);

  for (E = 0; E < S.Count-1; E++) AddTranslation(S.Names[E], S.ValueFromIndex[E]);



  S.Free;

  IniFile.Free;


}


//--------------------------------------------------------------------------------
//
// ADDTRANSLATION
//
// - NOTAS: las asignaciones de cadenas del tipo Entry[E].Text = Text; si mal
//   no recuerdo se habrán de cambiar por strcpy(Text, Entry[E].Text);
//
//--------------------------------------------------------------------------------

void TLanguage::AddTranslation(char* ID, char* Text)

{
  //Variables

  u16      E; // entry

  bool      Exists;


  //Inicio

  Exists = false;



  // check if the ID already exists

  for (E = 0; E < high(Entry); E++)
  {

    if (Entry[E].ID == ID)
    {

      Exists = true;

      break;

    }



    if(Exists)
    {

      // update translation

      Entry[E].Text = Text;

    }
    else
    {

      // create new translation entry

      SetLength(Entry, Length(Entry)+1);

      E = High(Entry);

      Entry[E].ID = ID;

      Entry[E].Text = Text;

    }

  }//end for



  // duplicate some entries for compability with USDX skins

  if (ID == 'SING_SCORE') AddTranslation('SONG_SCORE', Text);

  if (ID == 'SING_SCORE') AddTranslation('SONG_SCORE_WHEREAMI', Text);

  if (ID == 'SING_CHOOSE_MODE') AddTranslation('SING_MENU', Text);

  if (ID == 'SING_OPTIONS') AddTranslation('SING_OPTIONS_WHEREAMI', Text);

  if (ID == 'SING_GAME_OPTIONS_DESC') AddTranslation('SING_OPTIONS_DESC', Text);

  if (ID == 'SING_CONTINUE') AddTranslation('SING_LEGEND_CONTINUE', Text);

  if (ID == 'SING_CONTINUE') AddTranslation('SING_TOP_5_CHARTS_CONTINUE', Text);

  if (ID == 'SING_TOP_5_CHARTS') AddTranslation('SING_TOP_5_CHARTS_WHEREAMI', Text);

  if (ID == 'SING_SONG_SELECTION') AddTranslation('SING_SONG_SELECTION_WHEREAMI', Text);

  if (ID == 'SING_DIFFICULTY') AddTranslation('SING_DIFFICULTY_DESC', Text);

  if (ID == 'SING_DIFFICULTY') AddTranslation('SING_DIFFICULTY_WHEREAMI', Text);

  if (ID == 'SING_ENTER_PLAYER_NAME') AddTranslation('SING_PLAYER_DESC', Text);

  if (ID == 'SING_ENTER_PLAYER_NAME') AddTranslation('SING_PLAYER_WHEREAMI', Text);

  if (ID == 'SING_SING_MODE') AddTranslation('SING_MODE', Text);

  if (ID == 'SING_OPTIONS_GAME_DESC') AddTranslation('SING_OPTIONS_GAME_WHEREAMI', Text);

  if (ID == 'SING_OPTIONS_GRAPHICS_DESC') AddTranslation('SING_OPTIONS_GRAPHICS_WHEREAMI', Text);

  if (ID == 'SING_OPTIONS_SOUND_DESC') AddTranslation('SING_OPTIONS_SOUND_WHEREAMI', Text);

  if (ID == 'SING_OPTIONS_LYRICS_DESC') AddTranslation('SING_OPTIONS_LYRICS_WHEREAMI', Text);

  if (ID == 'SING_OPTIONS_THEMES_DESC') AddTranslation('SING_OPTIONS_THEMES_WHEREAMI', Text);

  if (ID == 'SING_OPTIONS_RECORD_DESC') AddTranslation('SING_OPTIONS_RECORD_WHEREAMI', Text);

  if (ID == 'SING_OPTIONS_NETWORK_DESC') AddTranslation('SING_OPTIONS_NETWORK_WHEREAMI', Text);

  if (ID == 'SING_OPTIONS_SOUND_PREVIEW_VOLUME') AddTranslation('SING_OPTIONS_SOUND_PREVIEWVOLUME', Text);



}//end AddTranslation



//--------------------------------------------------------------------------------
//
// TRANSLATE
//
//--------------------------------------------------------------------------------
char* TLanguage::Translate(char * Text)
{

  //Variables
  u16   E; // entry

  char* Result = Text;


  //Inicio

  for(E=0; E<high(Entry); E++)  if (Text = Entry[E].ID) Result = Entry[E].Text;

  return Result;



}


Bueno, a seguir comentando, sugiriendo, etc, etc... que así es como se avanza.

Y sigo en mis trece de que alguien con vocación de jefe de proyecto nos ayude a organizar, porque Jbom y yo hemos dicho "palante" pero eso lo mismo no quiere significar que seamos los más indicados.
la verdad que me encantaría ayudar con este proyecto, pero como ya he dicho de pascal ni idea; es muy dificil o muy diferente al c? en caso negativo si me miro lo básico por encima y como se declara cada cosa me bastará para portar?
Sin mirame nada entiendo bastante del código asi que creo que podré ayudar
en principio creo, pero no estoy seguro, que vale cualquier micro por USB para el boogie y el HSM
Estructuras de control en Pascal

EDIT: Mejor lo enlazo también en el primer post
Ok, gracias; con eso me vale. Entonces me apunto definitivamente.
PD:Habría que organizarse un poco, repartirse el trabajo, mirar la jerarquía de los archivos y ver cuales depende de cuales y empezar por los de más abajo y también establecer unas pautas comunes a la hora de reescribir el archivo tales como intentar llamar a las variables nuevas(si esque las necesitamos, que por otro lado no creo XD) de forma parecida, hacerlo todo limpio y estructurado, etc..
Wow, se ve entretenido...
Pero seguire esperando con ancias el stepmania [fumando]
señores puestos a portar yo portaria el ultrastar deluxe que es el mejor de todos, es mejor que el ultrastar y el ultrastar-ng, ya que podemos realizar competiciones con los colegas.Yo lo uso bastante en el portatil con los colegas para echar unas risas y esta bastante interesante el programa en cuestion.

Siento mucho no poder ayudar xq no entiendo de programacion pero si pudiese hacer algo lo haria encantado asi que podeis contar conmigo para lo que querais.

Un Saludo
@blackjoe: ten en cuenta que lo vamos a tomar como aprendizaje y por eso es mejor empezar con la versión básica que debería presentar menos quebraderos de cabeza.
Vamos, que inicialmente seremos ambiciosos sólo hasta cierto punto. Si nos sale bien no habrá razón para dar algún pasito más y presupongo que las funcionalidades del deluxe no serán tan difíciles de implementar sobre la base que ya se pueda tener.

Aparte, como nota curiosa, en la página oficial del juego tienen colgados vídeos mostrando las virtudes del mismo y especialmente cómo desfasa el personal echando unas partidillas.

http://ultrastar.ovh.org/

Ah! y perrito piloto para quien adivine si el personaje de las mechas rosas que tiene el micro en el primer vídeo es un tío raro o una tía rara.
no tengo mucha idea de pascal, pero en C me defiendo, asi que si os decidis a empezar a hacerlo mas o menos organizado contar conmigo, de momento me empezare a mirar algun tuto de pascal ademas de lo que hay linkado

realbrucest tienes un mp


saluz!!
@realbrucest: Lo primero que tendriamos que hacer seria hacer el arbol de dependencias y luego codificar como comenta Anarcadio. Estoy liado con el arbol a ver si puedo colgarlo esta noche.
que es,en pascal, cardinal?
EDIT:Si no me equivoco es un unsigned int, no?
EDIT2: Estoy reescribiendo uscreenloading y no voy mal, pero estoy viendo que uno de los archivos que primero deberíamos reescribir es uthemes, aunque sea muy grande
Jbom escribió:@realbrucest: Lo primero que tendriamos que hacer seria hacer el arbol de dependencias y luego codificar como comenta Anarcadio. Estoy liado con el arbol a ver si puedo colgarlo esta noche.

@Jbom: Okis, pues cuando tú puedas, que ya sé que a la hora que es para hoy va a ser ;) Va urgiendo ya un poco de orden en vista de que la gente arrima el hombro. Buena cosa.

@Anarcadio: junto con la prioridad de los archivos no dudes en postear en cuanto a las normas de estilo que creas convenientes. Ya iré arreglando el post inicial en cuanto tengamos el árbol de dependencias y acordemos lo demás.

@Valrov: pues estamos más o menos en la misma situación; yo hice alguna cosilla con Delphi y el pascal no lo tengo olvidado del todo, aunque de orientación a objetos ando regular. Pero ya ves, que no estamos solos y así es más fácil, además de que con sólo echarle ganas a lo que sea también se consiguen resultados.
MP respondido y otro para Jbom.

-------------------

Y una duda que me ha surgido con el pascal:

PSI: psmallintarray; //fuera aparte de que este tipo de datos nunca lo había usado
I := PSI^[S]; //no sé para qué sirve aquí el operador ^ ni cómo se pasaría a C++.
realbrucest escribió:
Jbom escribió:@realbrucest: Lo primero que tendriamos que hacer seria hacer el arbol de dependencias y luego codificar como comenta Anarcadio. Estoy liado con el arbol a ver si puedo colgarlo esta noche.

@Jbom: Okis, pues cuando tú puedas, que ya sé que a la hora que es para hoy va a ser ;) Va urgiendo ya un poco de orden en vista de que la gente arrima el hombro. Buena cosa.

@Anarcadio: junto con la prioridad de los archivos no dudes en postear en cuanto a las normas de estilo que creas convenientes. Ya iré arreglando el post inicial en cuanto tengamos el árbol de dependencias y acordemos lo demás.

@Valrov: pues estamos más o menos en la misma situación; yo hice alguna cosilla con Delphi y el pascal no lo tengo olvidado del todo, aunque de orientación a objetos ando regular. Pero ya ves, que no estamos solos y así es más fácil, además de que con sólo echarle ganas a lo que sea también se consiguen resultados.
MP respondido y otro para Jbom.

-------------------

Y una duda que me ha surgido con el pascal:

PSI: psmallintarray; //fuera aparte de que este tipo de datos nunca lo había usado
I := PSI^[S]; //no sé para qué sirve aquí el operador ^ ni cómo se pasaría a C++.



Al menos en Modula-2 (sucesor de Pascal), el operador ^ es de direccionamiento con punteros.

Taiyou
Taiyou escribió:Al menos en Modula-2 (sucesor de Pascal), el operador ^ es de direccionamiento con punteros.

Taiyou


Duda resuelta.

Gracias Taiyou.

-----------------------

EDIT:

Dejo en el post principal dos enlaces más en la categoría de información. El fantástico manual de Hermes sobre GX y un artículo sobre programación de chips utilizados en micrófonos y su acceso mediante usb; éste último tan sólo lo he leído por encima porque ando ahora con el EEE PC y para los tochos es un tanto coñazo la pantalla de 7 pulgadas. No sé si nos será realmente útil el artículo de los PIC.

- USB and PIC Microprocessors 16C745 and 18F2455
- Graficos 3D para Wii (PDF + Ejemplos) por Hermes
Veamos, tras mi primera toma de contacto con pascal me surgen unas pequeñas dudas que os comento.
Lo primero esto es el código:
/*UScreenLoading*/

//uses SDL, SysUtils, UMenu, UThemes;

class TScreenLoading {
public:
int TextProgress;
bool Fadeout;
void TScreenLoading;
bool ParseInput( unsigned int PressedKey; int ScanCode; bool PressedDown);
void onShow;
}

//uses UGraphic, UTime;

bool TScreenLoading.ParseInput
{result =true;}

void TScrennLoading::TScreenLoading()
{
int I;
//He omitido inherited create;
AddBackground(Theme.Loading.Background.Tex);
// {$IFDEF WIN32}
for (i=0;i<=High(Theme.Loading.Static);i++)
{AddStatic(Theme.Loading.Static[i]);}

for (i=0;i<=High(Theme.Loading.Text;i++)
{AddStatic(Theme.Loading.Text[i]);}

TextProgress := AddText(Theme.Loading.TextProgress);
//{$ENDIF}
Fadeout = false;
}

void TScreenLoading::onShow(void)
{
//nada
}

Corresponde a Uscreenloading.pas. DUDAS:Declara dos constructores create y override y luego override no lo usa ni nada también crea un prodecure override. De momento los he ignorado.
Mi otra duda corresponde a la parte en la que dice inherited create; no entiendo muy bien cual es su función.
Lo último no es una duda, es más bien que me estoy volviendo loco con las constantes declaradas en otros archivos ya que no se si pertenecen a una clase o a una estructura y por tanto no se si usar :: o . aunque he usado punto en todas ya que en teoría si son parte pública de una clase se puede usar el operador punto, no?
PD:Se me olvidaba, me he comido {$IFDEF WIN32} y {$ENDIF} por todo el morro XD

EDIT:Mirad lo que he visto en wikipedia investigando acerca del ultrastar-ng: "USNG features better pitch detection with fast fourier transform than Ultrastar and Ultrastar Deluxe which use autocorrelation. Multiple simultaneous tones can be detected and separated by the FFT post-processing algorithm, but the game currently only uses this information in the practice screen, not in the singing screen.
A feature unique to USNG is drawing the singing pitch as a line on the screen, in addition to the notes. This allows the player to easily correct his singing pitch instead of having to guess which way to correct."
Una vez hayamos reescrito este y entendamos como funciona, podemos intentar adaptar cosas del ng[/i][/i]

EDIT2:Creo que podemos pasar de reescribir zlportio: Description: This unit allow your application direct access port input and output under all versions of Microsoft Windows®
y también ddkint:This unit include service function to work with NT drivers and some constant from ntddk.h
@Anarcadio: lo de las globales que están sueltas en cada uno de los archivos habrá que ver si nos interesa terminar insertándola como atributos de la clase más apropiada.

@Jbom, se te espera para poner un poquillo de orden que los archivos chicos se van a acabar dentro de poco (es un decir) y repetir los grandes da más coraje :p

Me sumo a la petición de que alguien nos ilumine en cuanto a ¿para qué sirve el modificador override en pascal? Ya me lo he encontrado unas cuantas veces y esas líneas las he dejado sin tocar.

Apunte importante, es que acabo de pasar a C++ el UIini.pas, uno de los archivos tochos que espero que nadie más esté trabajando con él.

Y mirando la lista de anotaciones, otra cosa:
- En algún momento tendremos que sobrecargar los operadores de asignación, comparación y suma. Éste último para que nos concatene cadenas ya que en pascal se usa mucho. Con los otros dos también nos evitaríamos tener que recurrir a funciones adicionales para trabajar con strings.

-----------

EDIT: se me había pasado por alto el edit de Anarcadio. Apunto ahora en el post principal que podemos pasar de los archivos que comentas.
Joder... en vista de la caña que llevais, anteriormente no he dicho nada xD

Ánimo con el proyecto!
¿Por qué no registráis un nuevo proyecto en Google Code, SourceForge o similar, y os organizáis un poco?

Yo tengo experiencia con repositorios SVN, así que si os puedo ayudar con ello...

Ánimo con el proyecto.
@lolololailo: precisamente lo del SVN me lo he planteado varias veces en esto dos últimos días, pero resulta que de organizar un CVS (o SVN) propio, pues como de tantas otras cosas, ni idea.
Pero, si resulta que se nos puede echar un cable de tanto en tanto también con esto pues de PM. Dentro de un rato me pongo a mirarme cómo registrar el proyecto en alguno de esos dos sitios.
Como le he ido diciendo a los demás, que sin compromiso ninguno, muchísimas gracias por tu predisposición, cuando haya algún ratillo de tiempo libre y ganas pues uno se pone, y si faltan las dos cosas pues nada. Pero de momento ya me has animado a mirarme lo del hosting de SVN ;)

Saludos.

-------------------------------

EDIT:

Cuando lo tengamos un poco más claro nos lo vamos a llevar a SourceForge entonces.
Se aceptan todo tipo de sugerencias en cuanto a cualquiera de los campos que solicitan para el registro de un nuevo proyecto:

- Project Name
- Unix Name (max 15 caracteres)
- Public Description (para mostrar en las búsquedas)
- Registration Description (descripción técnica de carácter interno)

Todo debe estar redactado en "proper English", y resulta de gran importancia la adecuada redacción de la última categoría puesto que de ella depende la aprobación de SourceForge para alojar nuestro proyecto.

Con respecto a la licencia, que sería el siguiente paso, no sé si es obligado emplear la misma del original en el que nos basamos.

Bueno, a sugerir. ¿UltraStar Wii o quizá algo "más autóctono"?
Respecto a la licencia, creo que lo más conveniente sería respetar la GPL original, aunque utilizando la versión 3 de la misma.

No obstante, se puede consultar en http://www.fsf.org/licensing/licenses/index_html#GPLCompatibleLicenses la lista de licencias compatibles con la GPL del ultrastar original.
En el hilo del Revolution Engine se posteo esto que tiene muy buena pinta:
una demo: http://www.streber-pm.org/demo/
Para gestionar el proyecto, yo por mi experiencia recomendaría usar Trac, aunque desconozco que herramientas provee el propio sourceforge.

Podeis ver una demo en http://www.hosted-projects.com/trac/TracDemo/Demo
lolololailo escribió:Para gestionar el proyecto, yo por mi experiencia recomendaría usar Trac, aunque desconozco que herramientas provee el propio sourceforge.

Podeis ver una demo en http://www.hosted-projects.com/trac/TracDemo/Demo

Tiene buena pinta; la verdad que yo tambien desconozco las herramientas que pueda tener sourceforge
EDIT: He encontrado una web que da hosting gratis y con espacio ilimitado y que trae instalado ya trac y subversion: http://www.assembla.com/
yo creo que aunque tengamos el sourceforge podemos usar esto, no creeis?
Vaya, el assembla ése tiene muy buena pinta. Yo me retiro de la pantalla en cuanto acabe de postear, así que si alguien se registra y lo curiosea pues eso ya lo tenemos ganado.

En cuanto a hospedar en SourceForge, me he puesto a mirar más detenidamente para ver si incluía Frac como una de sus herramientas y cuando me ha dado por buscar comparativas en google, cansado de no sacar mucho en claro buscando las características de cada uno, en todos los artículos que he encontrado recomiendan el uso de Google Code en su lugar a no ser que se pretenda llevar un proyecto de una embergadura colosal (así de exagerada es la gente). Sobre todo ensalzan la facilidad de uso del sistema de Google.

Y pues eso, el que trastee algo con lo que ofrece el assembla que comente y si eso empezamos a organizarnos allí. Por mi parte me tocará descubrir cómo funciona Frac, pero más fácil que ir en plan compadre como ahora seguro que resulta.
Ok, ya lo he creado; tiene chat, wiki y un monton de chorradas XD. Os creais una cuenta, me lo decís y os agrego al grupo.
Acceso público a los documentos (aunque de momento aun no hay): http://www.assembla.com/spaces/ultrastarwii/documents
Yo sería más partidario de utilizar SourceForge, pero hasta que activen el proyecto, podemos usar el assembla este...
La verdad es que veo interesante el proyecto en el que os estais metiendo y me gustaria colaborar aunque no se si tendria mucho tiempo. Trabajo como programador grafico en OpenGL tanto en Delphi como C++. No tengo muy claro como es el Pascal que se uso para la programacion del juego. Nunca lo he tocado directamente ya que pase de Pascal normal (sin objetos) a Delphi. En cuanto a portar de Pascal a C++ yo propondria sacar primero todo el codigo de opengl del codigo original para separarlo y portar el codigo a C++. De ese modo se podria tener un port del juego en C++ para PC. Siempre es mas comodo probar las cosas en el PC que en la Wii. Una vez que el juego portado funcione en PC simplemente habria que pelearse con la parte opengl, con el analisis de la voz y con detalles especificos del C que pueden ir surgiendo.
Aclarando primero que no tengo mucha idea de programación más allá de PHP, y algunos otros lenguajes interpretados; no me ha quedado del todo claro porqué el empeño es reescribir el UltraStar en C++ para portarlo luego a Wii, en lugar de plantearse el portar directamente el UltraStar NG que ya está escrito en C++.

Me gustaría que alguien con más conocimientos que yo aporte algo de luz.
Acabo de echar un vistazo al codigo y en principio me parece que esta en Delphi. El arcchivo del proyecto es de delphi y lo he abierto sin problemas con la version 6. No me compila por que me da un error en los archivos de recursos y en las units de opengl. Ellos utilizan la version 1.2 y yo la 1.5. Esta tarde cuando llegue a casa intentare hacerlo compilar para cacharrear un poco con el codigo.
A ver, inciso para una pausa reflexiva y nos replanteamos muy en serio lo del NG.

@lololailo: pues si te digo la verdad porque los que me había dado por trastear eran el Ultrastar original y el Deluxe. En su momento no me encontré con el NG en sourceforge, con lo cual no miraría precisamente bien. Y vamos, que dí por hecho que sólo tendríamos acceso al código en Pascal (o delphi como también he visto ahora mirándolo todo más calmadamente). Bueno, de todos modos no considero que lo que ya he pasado resulte trabajo hecho en valde ya que de otro modo me hubiese dado más pereza meterme en el código.

@Anarcadio: ya me he registrado en Assenbla, cuando me puedas me agregas.

@gobo26: ¿entonces deberíamos de partir de aquí (SurceForge Ultrastar NG)?. Nada, quien me iba a decir que hoy podríamos avanzar tan rápido XD. Ahora recuerdo que alguien lo posteo algo más atrás... eso me pasa por cabezón.

Y bueno, que en un plis vuelvo a arreglar el post principal, además de pillarme el susodicho código en C++. Aunque ahora el trabajo si vaya a resultar transformar el OpenGL que se encuentre en GX, localizar funciones de PC y reemplazarlas por las que tengamos en libogc o reescribirlas... Vamos, trabajo del que ya no es limitarse a reescribir (ergo, del que me cuesta más). Pero en principio también hay que verlo positivamente, somos los mismos que antes pero ya tenemos toda la parte primera resuelta. Y allá que vamos igualmente.

Si alguien no está de acuerdo con que demos por resuelto todo el engorro del Pascal to C++ de un plumazo, que hable ahora o calle para siempre.

Y también recordar a todo el interesado en meterse en faena que se vaya creando un usuario en el servicio que encontró Anarcadio:
http://www.assembla.com/

Por cierto, que la Wikipedia no es que se explaye demasiado comentando características de esta versión
Wikipedia anglosajona escribió:UltraStar Next Generation (USNG) is a similar game written in C++. USNG runs on Linux. USNG features better pitch detection with fast fourier transform than Ultrastar and Ultrastar Deluxe which use autocorrelation. Multiple simultaneous tones can be detected and separated by the FFT post-processing algorithm, but the game currently only uses this information in the practice screen, not in the singing screen.

A feature unique to USNG is drawing the singing pitch as a line on the screen, in addition to the notes. This allows the player to easily correct his singing pitch instead of having to guess which way to correct.

The graphics rendering is based on OpenGL for high performance even on slower machines, with full effects. H.264 and other background video formats are supported using ffmpeg.
vale ya estais agregados todos
estube echando un vistazo al proyecto en C++ de sourceforge y tiene buena pinta. Estube mirando y la parte grafica esta bastante separada. Solo encontre codigo OpenGl en dos ficheros sdl_gl y video_driver. Parece buena opcion pa empezar.
Bueno, pues post inicial editado por enésima vez para anunciar que nos decantamos por el NG y mis disculpas a lololailo por tenerlo tan liado desde el principio (si es que no se puede dejar que el más torpe sea el que empiece a organizar el cotarro... XD)
Vale, ya he subido al trac una carpeta con el ng original (más por enredar que por otra cosa, pero bueno XD) y me he mirado un poco el código, respecto a este:
Para el opengl usamos las gl2gx que han puesto antes,no?
Hay algun port de las SDL para wii/cube, porque las usa el ng
Hay que empezar a readaptar los botones y ya si que deberíamos empezar a investigar el acceso al micro
EDIT: Si quereís estar al día de las acutalizaciones, usad nuestro SVN: http://svn.assembla.com/svn/ultrastarwii como ya he dicho, de momneto sólo he subido el ng original
Bueno pues arbol de dependencias a la papelera, jajajaja.

@Anarcadio: Creo que no deberiamos de usar las gl2gx, yo me decantaria por gx directamente pues asi lo hacemos bien desde un principio, mas dificil... pos si, pero mejor y asi aprendemos lo que tenemos que aprender. Yo estoy liado apendiendo gx asi que no creo que sea muy dificil esta parte y si no tenemos al gran Hermes para las dudas.
Esto... hoy paso de disculparme dos veces seguidas por no haber estado más atento y haber reparado en el NG antes [tomaaa]. Jbom, si me animo ya te pido disculpas por MP si eso...

El GL2GX deja mucho que desear. En su actual estado no va a ayudar demasiado. Toca GX.

Mirad qué curioso el vídeo que he localizado en youtube:
http://www.youtube.com/watch?v=Ad_EQnSv ... re=related

Resulta tentador acabar por copiarle las ideas al muchacho.
jajajaj realbrucest no merece una disculpa, son cosas que pasa en cualquier sitio, asi que no te preocupes. Del video lo que mas me impresiona es el menu y los graficos que tiene tan currados.
Bueno, creo que ha llegado el momento de organizarse,no creeis?
Vamos a ver yo dividiría el trabajo en:
-Reescritura de openGL a GX
-Adaptación para el wiimote
-Investigación del uso del micrófono
-La lectura de las canciones a través de la SD
y seguro que me dejo algo en el tintero
Ahora que cada uno comente que se le da mejor, que prefiere, etc.
Yo digamos que no tengo mucha experiencia con opengl y ya ni hablamos de GX asi que menos esa parte las demas me dan igual
Me pido el tema de lectura de las canciones/letras/etc. Es el único que me resulta familiar y en el que puedo avanzar más rápido.
Y con la noticia de hoy de la lectura desde DVD del video de Waninkoko, este apartado me resulta especialmente interesante pensando en esa futura implementación también.

Lo de los micros no sé por donde habría que empezar a pillarlo, y con GL y GX todavía no me defiendo en absoluto.
154 respuestas
Archivado
1, 2, 3, 4
Volver a Scene