[DS] DS CODE 0: "Los primeros pasos"

/////////////////////////////////INDICE ///////////////////////
DS CODE 0: "Los primeros pasos"
http://www.elotrolado.net/showthread.php?s=&threadid=560011

DS CODE 1: "Interrumpiendo"
http://www.elotrolado.net/showthread.php?s=&postid=1704954093
////////////////////////////////////////////////////////////////

Bueno pues aquí comienza lo que espero que sea una serie de tutoriales sobre programar en la Nintendo DS y más concretamente con libnds. Aqui está el zip con una plantilla para el proyecto
http://www.elotrolado.net/attachment.php?s=&postid=1704667288



1. REQUISITOS BÁSICOS

Lo primero que mencionaré de forma resumida es lo que necesitáis tener para poder empezar a programar con libnds:

-Devkitpro (http://www.devkitpro.org/)

Contiene todos los elementos para que podáis empezar: compilador, librería libnds y editor. Además lo configura todo automáticamente para los so windows.

Para instalarlo en linux seguid este excelente tutorial http://www.elotrolado.net/showthread.php?s=&threadid=543702

-Emuladores

Actualmente con Dualis nos apañaremos para todo. Evidentemente en hardware real sabe mejor, pero cuando lleves sacando y metiendo la tarjeta SD/CF más de 50 veces, agradecerás que vaya en emulador
http://dualis.1emulation.com/

-IDE (opcional)

Si bien el editor incluido en devkitpro es perfectamente válido y funcional, recomiendo la instalación de Visual Studio y que sigáis éste otro estupendo tutorial http://www.elotrolado.net/showthread.php?s=&threadid=459646

-Conocimientos de C++

Aquí no aprenderéis a programar. Asi que si queréis seguir estos tutoriales empezad primero con algo como http://c.conclase.net/curso/index.php


Esos son todos los elementos necesarios para trabajar. Ahora el primer paso que seguiremos es el de crear un proyecto. Para que ésto sea más fácil vamos a utilizar las plantillas que nos proporciona devkitpro. Así que lo primero que haremos es ir a la carpeta devkitPro\examples\nds\templates\ y compiaremos la carpeta combined que podremos pegar donde queramos (no puede haber en la ruta carpetas con espacios ) y renombrarla con el nombre de vuestro proyecto.
Ahora entraremos en ésta carpeta y haremos un rápido repaso por sus elementos

-Makefile

Éste archivo dice como deben compilarse las cosas. Hay un general en la carpeta raiz y otros más en cada carpeta correspondiente a los procesadores. Son éstos 2 los que tendremos que modificar en el futuro para añadir nueva funcionalidad.

-Arm9 y arm7

En estas carpetas tenemos la chicha de nuestro proyecto. Por defecto pondremos el código de cada procesador en sus respectivas carpetas source. Además encontramos ya en ellas un par de archivos. En éste tutorial se usarán arm7.cpp y arm9.cpp (ambos para c++) pudiendo borrar los otros. De momento no se va a explicar nada sobre éstos archivos.

-Crear archivos .bat

Para mayor comodidad de compilar, limpiar y recompilar se recomienda crear archivos .bat que faciliten éstas acciones. En la carpeta raiz del proyecto (donde está el makefile general) crearemos 3 archivos con extensión .bat con los nombres dados y pondremos los siguientes comandos según corresponda

*Compilar : make
*Limpiar: make clean
*Recompilar: make clean
make


El resultado de compilar serán los archivos .nds y .ds.gba. Sin embargo en ocasiones necesitaremos crear nosotros de forma manual un .ds.gba a partir de un .nds (si queremos usar gbfs por ejemplo) y para poder crearlos necesitaremos el archivo ndsmall.bin (que no encuentro de donde bajarlo). Añadiremos a los comandos compilar y recompilar o podremos lanzar desde línea de comandos la siguiente línea

cat ndsmall.bin nombre.nds > nombre.ds.gba

IMPORTANTE . Donde pone nombre, es el nombre de la carpeta del proyecto. Ésto es asi porque el archivo .nds que se genera tiene el mismo nombre que el de la carpeta. Se puede hacer también con reglas en el makefile, pero así es suficiente.



2. VISIÓN GENERAL DE LIBNDS

Bien, ya tenemos todo listo. Así que llega el momento de tratar con el elemento principal para nuestros desarrollos : libnds.

¿Qué es libnds?

Libnds es una librería que contiene una definición sobre los registros, de modo que no tengamos que estar recordando tropecientas direcciones de memoria ni que bits de cada registros hacen tal o cual cosa. Además se ofrecen ciertas funciones que facilitan un poco las cosas, siendo el 3D la parte más beneficiada en todo esto ya que cuenta con una serie de funciones para su manejo que lo hacen practicamente igual a usar Opengl. Así que si sabéis Opengl, tenéis el 50% hecho para programar 3D.

Entonces dicho ésto, ¿por qué "acojona" tanto usar libnds? Pues precisamente porque son definiciones sobre registros, tienes que saber todos los registros y cuá es su función para poder sacarle partido. Y ésta es la gran diferencia respecto a PAlib. Libnds te sirve todo el hardware de un modo más a meno que meras direcciones y registros, pero debes conocerlo para poder usarlo. En cambio PAlib lo oculta totalmente a cambio de una mayor facilidad de uso, ocasionando una programación en muchas ocasiones más rígida y menos libre que no te permite "domar" el hardware como se te antoje. Pero para "domarlo" es para lo que estamos aquí. Asi que ¡al ruedo!



3. VISIÓN GENERAL DEL HARDWARE

En éste capítulo se pretende dar sólo una aproximación de los elementos más importante que tendremos que tener en cuenta a la hora de programar respecto al hardware. Estos conocimientos tendrán que estar siempre presentes para poder hacer nuestros proyectos sin mayores contratiempos y que no nos pase que nos quedamos con cara de alelados al ver que tal cosa no se puede o no era así.

-RAM

Éste evidentemente es el primer elemento que tendremos que tener en cuenta. Tenemos 4 MBs de memoria disponibles para nosotros. ¿Y que significa ésto? Pues bien para entenderlo, vamos a ver "qué se pone en memoria".

Lo primero que resulta evidente que está en memoria es el código compilado, más concretamente el del arm9 (el arm7 se coloca en una memoria diferente) y por tanto sabemos que eso siempre está ocupado. Es por ello que siempre que podamos, evitaremos compilar los gráficos, música, etc junto con el código, pues estaremos ocupando ésta memoria de continuo con estos datos aunque no se estén utilizando en ese momento. Aqui entran en juego los sistemas de ficheros.

Luego tenemos las variables que estemos usando. En un principio es raro que tengamos problemas de memoria, pero en un hardware limitado como la DS no es cuestión de desaprovecharlo asi que es bueno que no utilicemos tipos de datos mayores de lo que necesitemos. Respecto a las variables es especialmente importante recordar que las varaibles estáticas y globales siempre están en memoria.

-VRAM

Ésta es la memoria más importante de todas, la memoria de video . Aquí situaremos nuestras paletas, sprites, texturas, mapas, etc , es decir todo lo que sean los recursos gráficos. En el futuro me referiré a ellos como recursos. De momento sólo decir que está dividida en diferentes bancos y que no todos ellos puede usarse para todos los propósitos ni tienen el mismo tamaño. Se tratará en profundidad.

-Otras memorias

Debido a su infrecuente uso no se mencionarán en los tutoriales. Aun así es bueno mencionar la existencia de una memoria de 32 kbytes dividida en 2 bloques iguales y asignable a cualquiera de los 2 procesadores (SIWRAM ) y una memoria caché usable sólo por el ARM9. Queda a cuenta del lector el como usarlas.

-Modos de video

La consola cuenta como es evidente con 2 pantallas físicas: una táctil y una "normal".Sin embargo internamente no se trabaja refiriéndose a pantalla de arriba y pantalla de abajo, si no pantalla principal y pantalla secundaria , permitiéndose además decidir cual de las pantallas físicas corresponde a cada una de esas pantallas lógicas. Por defecto y sin que hagamos nada la táctil es la principal y la otra la secundaria. Sin embargo hasta que no indiquemos el modo de trabajo de cada pantalla, no se visualizará nada en ella. Cada modo tiene un número y tipo de fondos que se pueden usar principalmente, además de poderse usar 3D en la pantalla principal usando uno de los fondos (el fondo 0). Mucho más sobre ésto proximamente.

-2D

Una vez más mencionaremos por encima lo principal para tratarlo con detenimiento en el futuro. Lo más importante es saber que que cada pantalla cuenta con sus sprites y sus fondos (que como se ha comentado antes dependen del modo de video elegido). Además hay que reservar la memoria (VRAM) para cada tipo de recurso (sprite, fondo, paletas extendidas) y de cada pantalla que queramos usar mediante los bancos de memoria. Vemos como todo va encajando poco a poco. Escoger modo, reservar banco de memoria para tal recurso de tal pantalla y cargar en esa memoria. Si esto está chupado.

Respecto a los sprites lo más importante es mencionar que sólo hay 128 "huecos" para poner información sobre ellos para cada pantalla. Dicho así suena raro asi que explicaremos un poco más. Si bien los gráficos en si (lo que es la imagen) se ponen en la dirección de memoria de video (VRAM) destinada a sprites, la información de como es ese sprite (posición, dirección de comienzo en memoria del gráfico, tamaño, etc) que necesita el hardware para dibujarlo, se pone en otro lugar y está limitada a 128 huecos. Ésto quiere decir que tu en memoria de video puedes tener tantos gráficos como quepan (según tamaño y profundidad de color) pero sin embargo no se pueden mostrar más de 128 a la vez en cada pantalla porque no hay más que ese número de huecos para la información. No debiera ser un gran limitación pero aun asi hay métodos para aumentar éste número remplazando la información de los sprites a medida que se pintan. Esto se pone interesante

Sobre los fondos, al igual que los sprites cada pantalla tiene los suyos (recordando una vez más que hayamos escogido el modo de video y hayamos reservado memoria para ello). Existen 3 tipos de fondos : de texto , rotacionales y los últimos que llamaré extendidos . Los 2 primeros funcionan por tiles (grupos de pixels) y el otro es como un buffer donde directamente pintamos pixel a pixel. Además la pantalla principal en uno de los modos de video puede funcionar como un buffer (realmente inutil teniendo el tipo de fondo extendido) o como un bitmap de gran tamaño.De momento nada más.

Por último las paletas. Cada pantalla lleva de regalo una paleta para sprites y una para todos los fondos . Cada una de estas paletas puede organizarse de 2 formas diferentes: o bien como una paleta de 256 colores o bien como 16 paletas de 16 colores cada una. También existe la posibilidad de reservar ciertos bancos de memoria para albergar más paletas de colores (paletas extendidas ). Paletas, muchas paletas. En un principio para los sprites usaremos siempre paletas (aunque existe un limitado modo para trabajar con sprites a 16 bits de color) y en los fondos se aprenderá a trabajar con paletas y sin paletas en el caso de los fondos extendidos (que permite ambas cosas).

-3D

Bueno llegamos al punto fuerte de libnds, el 3D. Como he comentado antes utiliza una serie de funciones que ofrecen un nomenclatura y funcionalidad practicamente idéntica a Opengl . Si bien es cierto que no todo va tan cristalino como quisiéramos ni tampoco es oro todo lo que reluce. En cuanto a limitaciones contamos con el tan odiado límite de 2048 triángulos en pantalla (ampliable mediante registros de captura) y el sólo poder usarlo en una pantalla (usable en las 2 también mediante el registro de captura). Las texturas como los demás recursos, requiere previamente de la pertinente reserva de bancos de memoria. Los formatos de las texturas son de diversos sabores y colores y se verán en un futuro quien sabe cuan lejano.



4. ESQUELETO BÁSICO Y PRIMER PROGRAMA

Primer programa ¿Ya? Si, porque no. Veamos cual es el esqueleto mínimo y luego pongamos nuestro típico "hello" para probar que tenemos todo bien instalado. En la mayoría de los casos sólo modificaremos el código del arm9 (como en este caso)

#include "nds.h"

int main(void) {
   while(1) {

   }
   return 0;
}


Ésta es la estructura absolutamente mínima (tan mínima que no hace nada) de un proyecto con libnds. En el vemos el bucle principal y lo realmente imporante, la inclusión de nds.h, es decir, de libnds.

Ahora vamos a hacer nuestro primer programa "útil". Comentaré de momento la funcionalidad de cada cosa sólo al lado de la línea.

#include "nds.h"
#include <nds/arm9/console.h> //necesario para poder llamar a consoleInitDefault
#include <stdio.h>

int main(void) {
        powerON(POWER_ALL);  //inicializa los cores 2D y 3D. Necesario en M3 (esto es por lo que algunos homebrew no arrancan)
   videoSetMode(MODE_0_2D | DISPLAY_BG0_ACTIVE);   //selecciona el modo de video 0 para la pantalla principal (sin activar 3D) y activa el fondo 0
   vramSetBankA(VRAM_A_MAIN_BG);    //reserva el banco A para fondos de la pantalla principal

   BG0_CR = BG_MAP_BASE(31);       //configura el registro del fondo 0 para que busque el mapa de tiles en el bloque 31. De momento os lo creéis

   BG_PALETTE[255] = RGB15(31,31,31);  //ponemos el último color de la paleta de fondos de la pantalla principal a blanco

   consoleInitDefault((u16*)SCREEN_BASE_BLOCK(31), (u16*)CHAR_BASE_BLOCK(0), 16);   //función básica proporcionada por libnds para poner texto. Sencilla pero con ciertas limitaciones

   iprintf("\n\n\tHello EOL!\n");   //nuestro esperado hello

   while(1) {
   }

   return 0;
}


Bueno si esto os funciona ¡Enhorabuena! Ya tenéis libnds funcionando y listo para que lo odi...disfrutéis y saquéis partido



5. ANEXO. TIPO DE DATOS

Éste primer anexo lo voy a dedicar a nuestro gran olvidado. Los tipos de datos. En libnds existen una serie de tipos de datos que deberemos conocer para desenvolvernos con soltura. En concreto hay 2 formas de llamarlos. Yo concretamente utilizaré la que utiliza (v) u-s bits

-unsigned char ->u8;
-unsigned short int ->u16;
-unsigned int ->u32;
-unsigned long long int ->u64;

-signed char ->s8;
-signed short int ->s16;
-signed int ->s32;
-signed long long int ->s64;

-volatile u8 ->vu8;
-volatile u16 ->vu16;
-volatile u32 ->vu32;
-volatile u64 ->vu64;

-volatile s8 ->vs8;
-volatile s16 ->vs16;
-volatile s32 ->vs32;
-volatile s64 ->vs64;


Como podemos ver v es de volatile, u de unsigned, s de signed y los bits se refieren a cuantos bits ocupa el tipo de dato. Es muy interesante cononcer cuanto ocupan.

¿Y ya está? ¿No falta "algo"? ..... ¿Y float? Bien, aquí todos a la vez. La DS NO TIENE FPU. Es decir, no existe como tal el tipo float. Si bien tu puedes declararlo y operar con el, usarlos te va a suponer una importante penalización de rendimiento. ¿Y qué uso?

Os presento a.... f32. f32 es el equivalente a float pero con coma fija y tiene la notación 1.19.12. No me entero de nada estás pensando. Bien, como no existen los tipos de coma flotante, los coma fija o fixed point in english utilizan tipos enteros. En este caso usamos un int (de ahi los 32 bits) y usamos el primer bit para signo, los 19 siguientes para la parte entera y los 12 últimos para los decimales. Menudo pitote estás pensando. Este tutorial no pretende enseñar los entresijos del uso de los tipos fixed point (queda como trabajo del lector) pero se darán una serie de descripciones que facilitarán su uso.

Bien seguimos entonces con f32. Como hemos visto internamente tiene una disposición de los bits un tanto especial y por tanto si lo inicializamos a 5 directament, no estaríamos guardando 5, si no 0 coma algo (recordemos que los primeros bits son para decimales). Para ello vamos a ver unos útiles definiciones de libnds

#define inttof32(n)-> pasa de int a f32
#define f32toint(n)-> pasa de f32 a int
#define floattof32(n)-> pasa de float a f32
#define f32tofloat(n)-> pasa de f32 a float


Asi mismo en cuanto a operaciones no se puede hacer todo tal cual. La suma y la resta si podremos hacerlas como siempre, pero para la división, multiplicación y raiz cuadrada haremos uso de estas funciones

f32 divf32(f32 num, f32 den)->division
f32 mulf32(f32 a, f32 b)->multiplicación
f32 sqrtf32(f32 a)->raiz cuadrada



Pues con eso ya tenemos todo lo necesario para ver un ejemplo

   f32 numero=0;            //el 0 se puede asignar directamente
   f32 numero2=inttof32(2);      //pasamos un tipo entero
   f32 numero3=floattof32(2.5);  //y ahora un tipo decimal
   int total;                     
   
   numero= mulf32(numero2,numero3);   //resultado 5
   numero= numero+numero;             //resultado 10
   total= f32toint(numero);            //guardamos el 10 como entero


Insisto en que se puede usar el tipo float sin que de error de compilación pero el primero paso para aumentar el rendimiento de tu proyecto es no operar con ellos.



Espero que os haya gustado el primero capítulo. Podéis comentar que os parece, si es fácil, díficil, poco completo, que no entiendes, lo que sea. Los siguientes subirán exponencialmente en dificultad y en contenido "palpable".

//////////////////////////////////////////////////////////////////

En las siguientes versiones pondré al final de este modo un zip con los ejemplos de lo hablado en el tutorial. En este caso están las plantillas vacías (en próximos tutoriales se complementarán) y los ejemplos de hello y número con coma fija

http://www.elotrolado.net/attachment.php?s=&postid=1704667288
Aquí está la plantilla del proyecto, ya que webez no puede ponerlo :P
Five points.
Muy bueno, sí señor. ¿Los siguientes capítulos los añadirás en este hilo o en uno diferente?
Hare un hilo diferente para cada uno y luego uno en plan indice. Son demasiado tochos para ponerlos juntos (y cuanto más código haya, aun más)
J O D E R ! ! !

Gracias webez, justo lo que andaba buscando!!! Se va a mis fvoritos para cuando acabe los exmanes de Junio empezar a programar para mi pequeñina!!! :)

PD: 5 estrellas para ti!!!
uaauu!!!!

me lo voy a seguir enterito!! 5 estrellas para el post!!

asiassss!
Buen tuto Webez, seguiré todo esto que antes solo conocia PAlib y me interesa bastante :)

Una cosilla, me he bajado el template y me tira este error al compilar:
Imagen

Creo que tengo todo bien instalado :-?
YaW


Hay que leerse el leer.txt!! Has dejado el arm7.cpp y template.c, que son lo mismo pero uno para c++ y otro para c. Asi que tienes un conflicto porque encuentra 2 funciones main
Un diez para ti. Ahora a ponerse al lío. Enhorabuena por tu trabajo. Haremos uso de él.
webez escribió:No me entero de nada estás pensando.

Que cabrito, ahí me ha pillao :P

Excelente [oki]. Con esto si que entra aún más ganas de meterse en el tema XD.
Aún no tengo ningún cartucho flash, pero iré "tirando" con los emuladores y tal. Aunque sólo sé un poquito de C, intentaré mirarme el cursillo ese de C++ que has puesto y en quanto formatée mi ordenata me pongo en ello, a ver si algun dia consigo algo [+risas]

Asias [ginyo] y enhorawena [boing]
Pues aqui esta la web con los recopilatorios...
-No tiene propaganda, ni enlaces externos, es algo simple, pero creo que cumple, hago referencia a la autoria, y a estas webs de alotrolado... si algun moderador cree que no deva ponerse este enlace, que lo diga y edito el post, no cerreis el hilo porfavor.


http://senpai.se.funpic.org/web_nds_programing/index.htm
La página está muy bien. El único inconveniente es que de vez en cuando voy corrigiendo cosas (faltas de ortografía, alguna cosa que se me va la pinza,etc). Asi que habría que actualizar alguna vez. Lo digo porque en el anexo ya está corregido un fallo (en la explicación de 1.19.12 he puesto 2 veces decimal) y en la web está lo anterior.
La carpeta combined la he llamado Rulo. Dentro he creado un archivo de texto y pegue el codigo de Hola EOL.

Le di a compilar y si, me compilo algo que no era el archivo que yo habia hecho. En este pone Hello World y me indica la posicion del raton en la pantalla tactil.

Ya se que puede parecer trivial, pero estoy seguro que mucha gente esta como yo ya que se dan demasiadas cosas por echo, y cosas que parecen tonterias para otros nos pueden parecer un mundo a la hora de no explicar cosas.

Gracias.
Gracias por la solución webez :)

¿Vas a centrar los tutos en C o en C++? Yo se de ambas cosas, aunque de C++ todavía no he hecho demasiado, ahora estoy con el proyecto final (un ajedrez xD)
Impresionante Webez, genial tutorial.

A la espera de nuevas entregas :P
Diskover


Bien. Aqui me tendrías que decir si has sacado o el .cpp o el .c como he dicho además de si has seguido las instrucciones respecto a los nombre. Porque si has cogido directamente el combined verás que tiene ya un código de ejemplo.De todos modos, ahora mismo acabo de cambiar además las plantillas (por unas que estén totalmente vacías) y subo el ejemplo del Hello EOL, que hasta que no pongo replicas no me deja subirlo.

Sobre lo que se da por hecho, te explico. Realmente devkitpro no necesita una expliacción para instalarse (es automático) y si tienes linux ya hay un link. Sobre como empezar el proyecto he puesto lo que realmente necesitas saber (o eso creo). Pero vamos, si en concreto echas algo de menos, dímelo para que me extienda más.

YaW


Soy un hombre firme en la OO así que estarán orientados a C++. De todos modos no serán para nada complicados de seguir ya que habrá muy pocas cosas que sean propias de C++ o no sean facilmente convertibles.


Para todos. Subidas plantillas nuevas (ésta vez si que están vacías), y el código para el hello y para los f32
A ver, que no lo consigo pillar.

Si, hice los BAT de compilar, limpiar y recompilar. Esto funciona bien.

Luego, con un editor de texto hice el programa tal como tu lo hicistes. Le puese extension cpp.

Creo que mi error esta en no saber donde poner este cpp que hago para que compile y tal.
Diskover


Los cpp (archivos con código fuente) y los .h (cabeceras que usaremos en el futuro) van , como dice el tutorial, en la carpeta source de sus respectivos procesadores. La carpeta source del arm7 dejala tal cual está y en la source del arm9 vas poniendo todos los archivos fuente que quieras. En éste caso pones (que ya habrá uno de todos modos de ejemplo) el arm9.cpp que has hecho. Si no bájate los ejemplos para ver las estrcutras.
DIOOOOOOOOSSS!!!!


Tu te aburrias en casa, o perteneces a una ONG pro-DS.


Madre q pedazo de tuto, y dice q va a seguir, yo es q de programacion poca idea asiq no creo q lo aprovexe mucho pero seguro q toda la peña q tiene ideas sobre algun homebrew puede sacarle mu buen partido.
sobre la web: de ahora en adelante, esperare unos dias para colgar las versiones, asi estaran mas depuradas... y si hay algun fallo muy grave, actualizo cuando sea ;)
perfecto :) aunque por ahora ya sabia lo que has explicado estaré atento cuando expliques como pasar un mapa de tiles a la pantalla :P
ETkoala


Antes que eso por lo menos haré otros 2 tutoriales (3 quizás). Para ir calentando, el siguiente será interrupciones, bancos de memoria y modos de video en profundidad. Y como anexo quizás algo de operaciones con bits.
Excelente tutorial WEBEZ, cuando acabe los examenes me pondre con las librerias libnds. De momento solo he hecho proyectos con las palib, pero quiero ver que soy capaz de hacer con las libnds.

Un saludo y cinco estrellas para ti. [ok]
Gracias por hacernos conocer mejor como funciona internamente esta pedazo de consola !

5 estrellas !!!!!
Fabuloso tutorial, te has ganado 5 estrellas, mi marcador en el navegador y un nuevo seguidor de tu tutorial X-D
Así podré poner en práctica mis recientes conocimientos en programación y algunas ideas que tengo en mente para DS.
Ahora solo me falta pillarme una DS, mientras tiraré de emulador.... :-(
Apuntado en favoritos, me ha gustado mucho tu manera de explicarlo.

Espero retomar mis proyectos después de exámenes ^_^U
Muy guapo tu tutorial ^^

muchas gracias por el [ok] [ok]
petasking87 está baneado por "ATPC"
bueno yo tengo un problema en los .bat (limpia, compila y recompila): no me reconoce "make" ni "cat" como comandos ni archivos por lotes.. estoy pegado en consola de comandos asi que no se corregirlo XD
PD: he probado haciendolo paso a paso y tambien directamente con los ultimos ejemplos aqui puestos
excelente trabajo ^^
gracias
petasking87


Si no te reconoce esos comandos es porque no tienes bien instalado msys (que viene con devkitpro). ¿Supongo que has instalado todos los componentes no?
petasking87 está baneado por "ATPC"
hola, siento molestarte de nuevo xD antes de nada, el msys no lo tenia instalado, lo puse y ya si m reconocio los comandos :P sin embargo dice que no encuentra ndsmall.bin y un par de fallos mas (este archivo esta tanto en la carpeta principal como en la del proyecto), bueno, te pongo una foto al utilizar "recompila":
vale, la foto sale demasiado pequeña, ilegible.. tendre que copiartelo jeje:

C:\Documents and Settings\Administrador\Escritorio\ds\devkitPro\progras\hello>recompila.bat

C:\Documents and Settings\Administrador\Escritorio\ds\devkitPro\progras\hello>make clean
make: *** /C/Documents: Invalid request code. Stop.

C:\Documents and Settings\Administrador\Escritorio\ds\devkitPro\progras\hello>make
make: *** /C/Documents: Invalid request code. Stop.

C:\Documents and Settings\Administrador\Escritorio\ds\devkitPro\progras\hello>cat ndsmall.bin hello.nds 1>hello.ds.gba
cat: hello.nds: No such file or directory

hale, muchas gracias por tu tiempo
El ndsmall.bin si no te has bajado mis plantillas, con devkitpro no viene. De todos modos si miras el tutorial again, verás que he puesto que realmente no es necesario, ya que se genera un ds.gba sin necesidad de ello.

Respecto a lo segundo, es tan tonto y sencillo como esto: no puedes poner el proyecto en escritorio ni mis documentos.
petasking87 está baneado por "ATPC"
si, ya esta todo. El metodo mas facil: borrar y volver a instalar en d: Ya he hecho un par de cosillas pero espero con ansia los siguientes tutos. un gran saludo :D
Habra que hecharle un ojo... Menuda currada de tutorial, a ver si me pongo y hago algo util para la DS. Saludos!
[flipa] [flipa] [flipa] [flipa] [flipa] [flipa] [flipa] [flipa] [flipa] [flipa]

Incrible webez, justo lo que andaba buscando desde hacía un tiempo.

Enhorabuena por el tuto!!!

Saludos !!!!
Te juro que me he leido el manual 20 veces pero hay algo que se me esta escapando y no lo veo.

He cojido de los codigos de ejemplo (tras instalar el devkip y el MSys) lo he copiado en d:\hello. Luego cuando compilo parece que todo va bien hasta que da el error 127.

Me podeis decir que es lo que hago mal??? [decaio]

Comentaros que a pesar de que da el error si que me crea el archivo hello.ds.gba y hello.dsn y puedo correrlos en el emulador Dualis, pero no en el VBA.

Gracias

RE:

Solucionado el problema reinstalando todo.
Impresionante.

Rara vez posteo por estos foros pero este post se merece mi mas sincera ovacion. Menudo curro te estas haciendo por nosotros!

Muchas gracias por todo Webez y mi enhorabuena y apoyo por este y los siguientes tutoriales de programacion en DS. Con gente asi da gusto visitar estos lares.

Saludos!
37 respuestas