UnityGB vous permet d'exécuter un Game Boy Rom dans votre projet Unity. Il a été écrit en C # et utilise uniquement Mono vous permettant d'exporter le projet vers n'importe quelle plate-forme pris en charge par Unity.
UnityGB est devenu le principal sujet de plusieurs articles comme CNET, Gameboy Emulator sur l'Oculus Rift: GameCeception.
UnityGB est toujours en version alpha, de nombreux bugs et pépins peuvent se produire. De plus, le code est loin d'être parfait et a besoin de beaucoup d'optimisation. Tout ce qui aide à accueillir! N'hésitez pas à contribuer à ce projet.
Veuillez également prendre un certain temps pour jeter un œil à nos autres applications sur notre site Web Takohi.com et nos autres actifs d'unité. ?
Hilarant Gameboy Emulator avec Leap Motion in Unity , par Pierce Wolcott
Oculus Rift Gameboy Emulator in Unity , par Shane O'Brien
UnityGB4BB10, Gameboy Emulator pour BlackBerry 10
Démo Web officiel , par Takohi
UnityGB peut fonctionner de plusieurs manières. Ce que vous devez faire est de faire votre propre implémentation sur la façon de gérer les entrées (contrôles) et les sorties (vidéo et son). Dans le package Unity et les sources, vous trouverez déjà une scène classique en diffusant la vidéo dans une texture classique, au fil audio la méthode OnAudiofilterRead et une entrée Joypad du clavier.
Un exemple de la façon d'implémenter les contrôles peut être trouvé dans DefaulmulatorManager.cs .
Lorsque vous souhaitez imiter une entrée du lecteur dans le jeu, il vous suffit d'appeler la méthode SetInput à partir de la référence de l'émulateur:
void SetInput(Button button, bool pressed);
Le bouton est une énumération avec ces valeurs:
public enum Button {Up, Down, Left, Right, A, B, Start, Select};
Par exemple, si vous souhaitez appuyer sur le bouton Démarrer lorsque le lecteur frappe le bouton d'espace:
if(Input.GetKeyDown(KeyCode.Space))
Emulator.SetInput(EmulatorBase.Button.Start, true);
else if(Input.GetKeyUp(KeyCode.Space))
Emulator.SetInput(EmulatorBase.Button.Start, false);
Un exemple de la façon d'implémenter la vidéo peut être trouvé dans defaultVideoOutput.cs .
Afin de sortir la vidéo de l'émulateur ou en d'autres termes, pour afficher l'écran du jeu Boy, vous devrez faire votre propre classe en implémentant l'interface IvideOutput .
Cette interface n'a que deux méthodes:
void SetSize(int w, int h);
void SetPixels(uint[] colors);
La méthode SETSIZE sera appelée après le chargement de la ROM. Il vous dira quelle est la taille de l'écran en pixels (160x144, il ne devrait jamais changer), vous pouvez donc initialiser votre chemin à afficher.
La méthode SetPixels sera appelée chaque fois que le cadre a été mis à jour. En tant que paramètre, un tableau de couleurs qui correspond à la couleur de chaque pixel. La taille du tableau sera la largeur de la hauteur x .
Voici une méthode pour convertir une couleur Uint en une couleur d'unité:
private Color UIntToColor(uint color)
{
byte a = (byte)(color >> 24);
byte r = (byte)(color >> 16);
byte g = (byte)(color >> 8);
byte b = (byte)(color >> 0);
return new Color(r / 255f, g / 255f, b / 255f, a / 255f);
}
Un exemple de la façon d'implémenter l'audio peut être trouvé dans DefaultAudioOutput.cs .
Avec Unity, la seule façon de produire dynamiquement audio est d'utiliser la méthode OnAudiofilterRead (Float [] Data, Int Channels) à partir d'un objet monobehaviour .
Dans le package, nous fournissons déjà un moyen de produire le creux audio de la classe par défaut Baudio-Output . Si vous souhaitez l'utiliser, attachez simplement ce script à un objet de jeu et ajoutez-y un composant Audiosource .
Si vous souhaitez toujours faire votre propre implémentation pour la sortie de l'audio, vous devrez faire une classe qui implémente l'interface iaudioOutput .
Cette interface a trois méthodes:
int GetOutputSampleRate();
int GetSamplesAvailable();
void Play(byte[] data, int offset, int count);
Les échantillons sont entrelacés (% 0 = gauche,% 1 = à droite). Cela signifie pour chaque échantillon: données [i] = échantillon gauche, données [i + 1] = échantillon droit.
Un exemple de la façon de gérer les fichiers de sauvegarde peut être trouvé dans defaultSaveMemory.cs .
Afin de gérer les fichiers de sauvegarde, vous devrez faire votre propre classe implémentant l'interface isavemmemory .
Cette interface n'a que deux méthodes:
void Save(string name, byte[] data);
byte[] Load(string name);
La méthode de sauvegarde est appelée lorsque l'utilisateur arrête le jeu et que la méthode de chargement est appelée lorsque le jeu est chargé. Le paramètre de nom est le nom du jeu actuellement joué.
À l'échelle mondiale, lorsque la méthode de sauvegarde est appelée, il vous suffit de stocker le tableau d'octets donné en tant que paramètre, puis de charger et de retourner ce même tableau d'octets lorsque la méthode de charge est appelée pour le même jeu.
Un exemple de la façon d'utiliser l'émulateur peut être trouvé dans DefaulmulatorManager.cs .
Le code ci-dessous est un moyen simple montrant comment initialiser et faire de l'exécution UnityGB avec un script monobehaviour .
Tout d'abord, nous créons une instance de l'émulateur et chargeons la ROM dans la méthode de démarrage .
void Start()
{
// Load emulator
IVideoOutput drawable = ...; // Reference to your IVideoOutput implementation.
IAudioOutput audio = ...; // Reference to your IAudioOutput implementation.
ISaveMemory saveMemory = ...; // Reference to your ISaveMemory implementation.
Emulator = new Emulator(drawable, audio, saveMemory); // Instantiate emulator.
byte[] rom = ...; // Load ROM binary.
Emulator.LoadRom(www.bytes); // Load ROM into emulator.
}
Ensuite, nous faisons fonctionner l'émulateur pendant la méthode de mise à jour du monobehaviour . Nous utilisons également cette méthode pour gérer les entrées de l'utilisateur et les envoyer à l'émulateur.
void Update()
{
// Input
if(Input.GetKeyDown(KeyCode.Space))
Emulator.SetInput(EmulatorBase.Button.Start, true);
else if(Input.GetKeyUp(KeyCode.Space))
Emulator.SetInput(EmulatorBase.Button.Start, false);
...
// Run
Emulator.RunNextStep();
}
N'oubliez pas d'attacher le monobehaviour précédent à un objet de jeu afin de le faire fonctionner.
