Time Pilot

Konami, 1982

Kristof Tuts already programmed a fantastic version – Vector Pilot – for the Vectrex but I could not help myself to port the arcade game, too. After all I already had the Vector Pilot overlay and knew that I could get the arcade game to use it. Plus it is always nice to play the actual arcade game: I also have the arcade pcb here (and had it in my universal cab. for quite a while) so am quite fond of the game. All four romset versions were ported but besides the nicer attract in the licensed ones (they show the UFO level in the far future of.. 2001) they all feel and play the same to me.

This was -in principle- a lot of fun and pure joy to port since the Time Pilot game works great vectorized and with this game my vector object engine reached likely its culmination: everything can now not only be cached initially and drawn in a very simple manner (and ultra-fast) but now also more automatic paths are implemented, e.g. for brightness changes and esp. automatic clipping. Before the ‘sprites’ simply never left the screen so the few clipping things were simple and manually done. Much nicer now – just have to create and drop in new vector data plus specify a clipping region and let the engine do its thing. So can spend my time on the actual disassembling, porting and understanding of the arcade hardware.

Well, in principle this is the fun part but the early Konami games are just… awful in that they have an abysmal amount of small security/consistency code checks sprinkled about absolutely everywhere. Pooyan was already bad but this here was definitely worse. Now that would not be a problem for a simple emulation, even a static binary translation, but since I always want to also change the rom address space into a faster representation I had to hunt down every single one of those annoyances. And every single romset has its own checks, awful. Just. Awful. Well, eventually I found them all…

Input

One of the nice things in porting this is also that I am in control of everything so can add/adapt things – and thanks to Jérôme V. who had the idea I have spent the time to implement spinner support for Time Pilot. Which I have to agree is a lot of fun and just feels natural to the game. The spinner data is not just used as a joystick replacement but you can actually rotate faster with it, including on the high score entry page.

So besides the normal digital joystick option of the arcade game two spinner inputs are implemented, both using the usual grey-code encoder: the Atari Driving controller (which needs extra calibration for its fire button) and a Vectrex spinner (both buttons are mapped onto fire). These spinner options also differ in how their data is handed over to Time Pilot: the Atari spinner is twice as fast. This is due to the fact that the Atari one has a huge knob whereas the Vectrex ones I’ve here all use small ones so can be spun fast. So having these two different speeds feels better to me here for the game. During gameplay you can also press 1:/2: on the main controller to rotate and ‘3:’ to pause at any time on controller 1 so that the inputs are in-line with Vector Pilot (these button no. are printed as instructions on the overlay)

Please note: if the five-button controller is chosen as the VecFever menu input it overrides the input options

Vectorization

Tiles

Creating a vector back-end for Time Pilot was straightforward albeit time-consuming: first the font and other characters/tiles had to be vectorized and ‘combined-usage’ figured out. When looking at the gfx1 rom for this data it is obvious that something fancy is going on here software-wise: the characters for the font are all over the place, there is a lot of empty chars and quite a lot of dots in there, too. Plus a lot of chars – 512 of them.

This is due to a game design strategy: the entire playfield’s tile background is only used for either the player shots, the player explosion or the time jump animation. And these are mutually exclusive: when alive and shooting only shots can be shown – so if any text needs to be shown (e.g. the ‘A.D. 19xx’ one) you cannot shoot since these shots are not sprites. Otherwise the ‘Time Pilot’ logo is built out of a bunch of characters – the ‘SPACE’ in the bootleg simply overwriting these chars (pretty badly – they do look like using a different style).

So the first step was to figure out a way to basically convert the shots’ tiles (each shot can be a combination of 2 tiles plus x and y mirrored) into simple, singular objects again and reorder them (plus the player ship) for visual stability. The player explosions are handled similarly. The time jump is actually unique in the backend in that it bypasses the fast, mostly precomputed path and vectorizes the animation for each char per frame. Was just easier to implement and when the animation is shown nothing else is going on anyways.

Sprites

Sprites were more straightforward: there are 256 sprite ids used by Time Pilot so first all these had to be manually vectorized. And then similar to the tiles the combined sprites – where two to four are combined to a bigger object – had to be handled. This was a bit more complex than usual since the game actually both does use a ‘raster-line’ wrap-around feature for combined sprites (the 3-sprites-wide cloud) and does some finicky things to hide two-wide sprites at times: there is no enable/disable flag in hardware, sprites are moved either outside of the visible screen to the side or outside of the clipping area. Ah, yes, and that was the last challenge: there is a clipping area used. Over the upper character lines and the one below the play area no sprites can be displayed. So my sprite engine here precalculates the vectrex data for unclipped sprites and automatically falls back to a version with clipping, if necessary.

Localization

//NAME="TIMEPLT"
//

GERMAN[] = {
    { 0, 0, "Spielfläche: Arcade" },
    { 0, 0, "Spielfläche: Zentriert" },
    { 0, 0, "Spielfläche: Vergrössert" },
    { 0, 0, "Vector Pilot" },
    { 0, 0, "Overlay unterstützt" },
    { 0, 0, "1 (Einfach)" },
    { 0, 0, "8 (Hart)" },
    { 0, 0, "Bonusleben: 10K 50K+" },
    { 0, 0, "Bonusleben: 20K 60K+" },
    { 0, 0, 0 },
    { 0, 0, 0 },
    { 0, 0, "Demoton: An" },
    { 0, 0, "Demoton: Aus" },
    { 0, 0, "255 (Cheat)" },
    { 0, 0, "High Score sichern" },
    { 0, 0, "deaktiviert" },
    { 0, 0, "Auto-Feuer: An" },
    { 0, 0, "Auto-Feuer: Aus" },
    { 0, 0, "                           Willkommen zur vektorisierten Version des Arcadespiels Time Pilot © 1982 Konami.     Kristof Tuts programmierte bereits die definitive 6809 Version für die Vectrex -Vector Pilot- welches nicht nur einen weiteren Level hat sondern sogar gekrümmte Vektoren for die Wolken benutzt. Plus hervorragende Overlays.   Da dieses Spiel offensichtlich sehr gut auf der Vectrex läuft - alles ist in Bewegung und keine ultragenauen Kontaktberechnungen - konnte ich mich nach Pooyan nicht zurückhalten auch Time Pilot mir anzusehen: sowohl Pooyan wie Time Pilot nutzen sehr ähnliche Hardware.    Die Hoffnung war auch, dass es weniger Zeit kosten würde die Romsets zu portieren und einen Vektorbackend zu entwickeln.         Da lag ich ja mal wirklich falsch, dies dauerte wesentlich länger.       Zunächst waren die Romsets sehr ärgerlich: ebenso wie Pooyan haben auch die Time Pilots eine grosse Menge an Konsistenzchecks auf den über das ganze ROM verteilt. Tests auf Ausgabecharacter (wie das Logo or (C) String), Tests der Sprungtabellen, Tests von Code der testet, Tests von dem Code der wiederum den Code testet der Tests testet und die Liste geht weiter.   Dies wäre im Prinzip kein Problem, wenn ich nicht wie üblich das Spiel in einen anderen Adressraum umwandeln wollte (was etwas Performance bringt). Also musste ich all diese Schlawittchen finden. Und diese Tests sind nicht in ähnlichen Orten bei den lizenzierten Roms: ein Konami Ingenieur damals generierte viele neue für jedes dieser lizensierten Roms. Schrecklich.              Auch das vektorisieren der Rasterhardware war zeitaufwändig: nicht nur das doppelte and Spritedaten zu malen, vektorisieren und eintippen sondern etliche werden auch kombiniert mit anderen um grössere Spriteobjekte auszugeben - bis zu vier 16x16 Sprites werden kombiniert. Und diese werden alle so benutzt, dass sie abhängig vom Hardwarespriteclipping und auch Schirmwraparound sind: es gibt kein Spritedisable sondern die einzelnen Sprites werden ausserhalb dieser Clippinggegend bewegt, um sie unsichtar zu machen.   Eine 3-Spriteweite Wolke im ersten Level jedoch wird sowohl links wie rechts teilweise ausgegeben, wenn sie exakt mittig im unsichtbaren Teil liegt, denn sie ist 48 Pixel breit und der unsichtbare Bereich nur 32 Pixel.         Überhaupt Wolken: dieses Spiel sieht aus, als wenn es sehr viel mehr Sprites hätte als die 24 in Hardware. Dass wesentlich mehr herumfliegen lieft and zwei kleveren Ideen: zum Einen werden alle Hintergrundwolken/Asteroiden gemultiplext, der Schirm ist zweigeteilt in oberen und unteren Teil und die CPU testet über einen Scanlineezähler (keine Interrupts hier) ob die Wolke bereits ausgegeben wurde. Und falls ja werden die Positionen geändert für den unteren Bereich: immer einen halben Schirm entfernt in x und y. Diese Aktion verdoppelt die Wolkensprites von 8 auf 16.        Der zweite Trick ist es den Characterbuffer der Spielgegend in eine Art Spriteemulationsmodus für die Spielerschüsse zu verwandeln: dieses sind alles Characters und keine Sprites und nichts anderes kann neben diesen Schüssen dann ausgegeben werden. Dies ist der Grund, warum man in der Zwischensequenz, wenn das Jahr ausgegeben wird, sich zwar drehen kann. Aber noch nicht schiessen.      Beide Methoden sind beeindruckend in Software zu machen für ein so frühes Arcadespiel.          Im Originalspiel wird die oberste Wolkenebene sogar über den Spielelementen ausgegeben und die anderen zwei Ebenen darunter was nicht funktioniert mit einem Vektordisplay. Deswegen werden hier alle Wolken/Asteroiden dunkel ausgegeben. Für mich funktioniert dies sehr gut, das Gefühl von Parallaxscrolling ist geblieben und da sie alle dunkler sind interagieren sie nicht mit den Spielelementen (sie werden ja nicht verdeckt von diesen).                            "},
    { 0, 0, "                           Willkommen zur vektorisierten Version des Arcadespiels Space Pilot, einem Bootleg von Konami's Time Pilot.      Dieses Spiel ist beinahe identisch zu Time Pilot - nur die nötigen Sicherheitschecks wurden umgangen. Und die Titelgrafik angepasst. Schlecht angepasst sogar, der 'SPACE'-Teil hat einen anderen Stil zum ungeänderten 'PILOT'-Teil dahinter. Selbst der KONAMI Name ist noch da, zunächst dachte ich dieses läge daran, dass die Spritegafik nicht angepasst wurde (das Spiel zeichnet KONAMI zweimal, einmal mit Characters und nochmal darüber mit identischen Spritedaten).  Aber nein - die Konamisprites sind leer im Space Pilotgrafikrom. Die Ausgabe wegzunehmen war dem Bootlegger wohl nicht mehr die Mühe wert...                      "},
    { 0, 0, "                           Willkommen zur vektorisierten Version des 1982 Atari-Arcadespiels Time Pilot, lizenziert von Konami.     Diese lizensierte Version hat einen netteren Attractmodus - der UFO Level ist hier präsent aber fehlt im original Konamirom - und eine Vielzahl anderer Sicherheitstests plus einen marginal neueren Code.  Aber ansonsten ist das Spiel identisch zu Konamis Original.                            "},
    { 0, 0, "                           Willkommen zur vektorisierten Version des 1982 Centuri-Arcadespiels Time Pilot, lizenziert von Konami.     Diese lizensierte Version hat einen netteren Attractmodus - der UFO Level ist hier präsent aber fehlt im original Konamirom - und eine Vielzahl anderer Sicherheitstests plus einen marginal neueren Code.  Aber ansonsten ist das Spiel identisch zu Konamis Original.                            "}
};

FRENCH[] = {
    { 0, 0, "Zone de Jeu: Arcade" },
    { 0, 0, "Zone de Jeu: Centrée" },
    { 0, 0, "Zone de Jeu: Agrandie" },
    { 0, 0, "Support du filtre" },
    { 0, 0, "couleur de Vector Pilot" },
    { 0, 0, "1 (Faible)" },
    { 0, 0, "8 (Elevée)" },
    { 0, 0, "Vie Bonus: 10K 50K+" },
    { 0, 0, "Vie Bonus: 20K 60K+" },
    { 0, 0, 0 },
    { 0, 0, 0 },
    { 0, 0, "Son du Mode Démo: Oui" },
    { 0, 0, "Son du Mode Démo: Non" },
    { 0, 0, "255 (Triche)" },
    { 0, 0, "Scores non" },
    { 0, 0, "sauvegardés" },
    { 0, 0, "Tir Auto.: Oui" },
    { 0, 0, "Tir Auto.: Non" },
    { 0, 0, "                           Bienvenue dans la version vectorisée du jeu d'arcade Time Pilot © 1982 de Konami. Kristof Tuts a déjà programmé la version '6809' ultime pour le Vectrex, 'Vector Pilot', qui non seulement bénéficie d'un niveau supplémentaire, mais utilise également des vecteurs courbes pour dessiner les nuages. De plus, il est agrémenté d'excellents filtres couleur. Comme ce jeu fonctionne apparemment très bien sur le Vectrex -tout est en mouvement et il n'y a pas de calculs de contact ultra précis- je n'ai pas pu m'empêcher de décortiquer Time Pilot après Pooyan: Pooyan et Time Pilot utilisent tous deux un matériel très similaire.    J'espérais aussi que le portage des paquets de roms et le développement d'un arrière-plan vectoriel prendraient moins de temps. Force est de constater que je me suis trompé. Cela a pris un peu plus de temps que pour Pooyan. Tout d'abord, il y a eu les paquets de roms qui se sont révélés très agaçants. Tout comme pour Pooyan, il y a une grande quantité de contrôles de cohérence répartis dans toute la rom. Il faut imaginer des tests sur les caractères de sortie (comme le logo ou la chaîne (C)), des tests sur les tables de branchement, des tests sur le code qui teste, des tests sur le code qui teste à son tour le code qui teste les tests (!), et la liste est encore longue...   En principe, tout cela n'aurait pas dû poser de problèmes si je n'avais pas voulu, comme à l'habitude, convertir le jeu dans un autre espace d'adressage (ce qui apporte un peu plus de performance). J'ai donc dû dégoter tous ces satanés tests. Et ces tests ne sont pas dans des endroits similaires pour les roms sous licence: un ingénieur Konami a eu l'idée à l'époque d'en générer beaucoup de nouveaux pour chacune de ces roms sous licence. Quelle horreur!              De plus, émuler le matériel en question et le vectoriser a représenté beaucoup plus de travail qu'avec Pooyan: non seulement il y avait deux fois plus de données de sprites (avec la moitié de la gamme de couleurs) mais certains sprites étaient combinés de plusieurs façons et dessinés comme des éléments plus grands - ainsi jusqu'à quatre sprites 16x16 étaient combinés. Il faur savoir que ceux-ci sont également tous édités de telle sorte qu'ils dépendent de l'écrêtage matériel des sprites et de l'aptitude de 'wraparound': il n'y a pas de désactivation des sprites à proprement parler, mais les sprites individuels sont déplacés en dehors de cette zone d'écrêtage pour les rendre invisibles. Cependant, un nuage du premier niveau constitué de 3 sprites de large sera partiellement rendu à gauche et à droite s'il se trouve exactement au milieu de la partie invisible, puisqu'il mesure 48 pixels de large et que la zone invisible hors écran ne fait que 32 pixels de large.         A propos des nuages, ce jeu semble utiliser beaucoup plus de sprites que les 24 du matériel. Le fait qu'il y en ait beaucoup plus qui se déplacent est dû à deux idées ingénieuses: tout d'abord, les nuages/rochers d'arrière-plan sont tous multiplexés, ce qui signifie que l'écran est divisé en une partie supérieure et une inférieure et que le processeur vérifie un compteur de lignes de balayage (sans interruption). Si le nuage supérieur a été affiché, Le processeur reprogramme la position de la moitié inférieure, toujours à un demi-écran de distance via des coordonnées (x;y). Ce multiplexage double les sprites des nuages visibles qui passent ainsi de 8 à 16.       La deuxième astuce consiste à transformer le tampon de caractères de la zone de jeu en une sorte de mode d'émulation de sprites pour les tirs des joueurs: ce sont tous des caractères et non des sprites si bien rien d'autre ne peut être produit à part ces tirs. C'est pourquoi, pendant la séquence entre 2 niveaux au cours de laquelle l'année est affichée, le joueur peut faire tourner le vaisseau, mais ne peut pas encore tirer.      Ces deux astuces sont impressionnantes d'un point de vue 'programmation logicielle' pour un jeu d'arcade ancien.          Dans le jeu original, la couche de nuages la plus haute est au-dessus des joueurs et des ennemis alors que les deux autres sont en dessous, mais comme ce n'est pas possible avec un affichage vectoriel, tous les nuages ont bénéficié d'une luminosité atténuée. Je pense que le résultat est assez convaincant: la sensation de défilement parallaxe est bien présente et comme les nuages sont tous un peu moins lumineux que les éléments du jeu avec lesquels le joueur interagit, ils ont l'air d'être en arrière-plan et n'interfèrent donc pas (puisqu'ils sont toujours dessinés visiblement 'sous' le joueur ou les ennemis).                            "},
    { 0, 0, "                           Bienvenue dans la version vectorisée du jeu d'arcade Space Pilot, une contrefaçon du jeu Time Pilot de Konami. Le jeu est quasi-identique à Time Pilot, seuls les contrôles de sécurité nécessaires ont été adaptés ou supprimés. Le graphisme du logo a également été adapté: Plutôt mal d'ailleurs, car la partie du titre intitulée 'SPACE' présente un style graphique différent de celle constituée par le mot 'PILOT' demeuré inchangé. Même le nom 'KONAMI' est toujours présent. Au début je pensais que c'était parce que les graphismes des sprites n'avaient pas été effacés (le jeu les dessine à la fois sous forme de caractères mais aussi avec des données de sprite identiques au-dessus de ces caractères pour une raison non déterminée). Mais non, il est masqué dans les graphismes de la rom de Space Pilot, donc je suppose que les contrefacteurs n'ont pas voulu se fatiguer à supprimer ces caractères...                      "},
    { 0, 0, "                           Bienvenue dans la version vectorisée du jeu d'arcade Time Pilot (1982) de Konami, sous license Atari. Cette version a un mode démo plus sympathique: le niveau des OVNIS est ici présent alors qu'il n'apparaît pas dans le jeu original de Konami.  Il y a également toute une myriade de contrôles de sécurité différents auxquels s'ajoute un code source un tout petit peu plus récent. Mais ceci mis à part, le jeu est le même que l'original de Konami.                      "},
    { 0, 0, "                           Bienvenue dans la version vectorisée du jeu d'arcade Time Pilot (1982) de Konami, sous license Centuri. Cette version a un mode démo plus sympathique: le niveau des OVNIS est ici présent alors qu'il n'apparaît pas dans le jeu original de Konami.  Il y a également toute une myriade de contrôles de sécurité différents auxquels s'ajoute un code source un tout petit peu plus récent. Mais ceci mis à part, le jeu est le même que l'original de Konami.                      "}
};

ENGLISH[] = {
    { 0, 0, "Game Area: Arcade" },
    { 0, 0, "Game Area: Centered" },
    { 0, 0, "Game Area: Overscan" },
    { 0, 0, "Vector Pilot" },
    { 0, 0, "overlay supported" },
    { 0, 0, "1 (Easy)" },
    { 0, 0, "8 (Hard)" },
    { 0, 0, "Bonus Life: 10K 50K+" },
    { 0, 0, "Bonus Life: 20K 60K+" },
    { 0, 0, "10K, 60K, 110K, 160K..." },
    { 0, 0, "20K, 80K, 140K, 200K..." },
    { 0, 0, "Attract Sounds: On" },
    { 0, 0, "Attract Sounds: Off" },
    { 0, 0, "255 (Cheat)" },
    { 0, 0, "High Score" },
    { 0, 0, "storage disabled" },
    { 0, 0, "Auto-Fire: On" },
    { 0, 0, "Auto-Fire: Off" },
    { 0, 0, "                           Welcome to the vectorised version of the arcade game Time Pilot © 1982 by Konami.     Kristof Tuts already programmed a definitive 6809 version for the Vectrex -Vector Pilot- which even sports an additional level and curved vectors for the background clouds plus excellent overlays. So since this game is obviously eminently suited for a vector display - everything moving around and no extremely precise contact handling - I could not help myself after Pooyan to take a look at the original, too: both Pooyan and Time Pilot use an extremely similar hardware.    The hope was that porting the romsets and creating a vectorized backend  this would not be all that hard and time-consuming.      Boy was I wrong, this took quite a bit longer than Pooyan. First were the romsets - just like with Pooyan there are a myriad of rom consistency checks sprinkled around the entire game. Checks of output chars (e.g. logo or (C) char), checks of jump table entries, checks of code which checks other things, checks of checks of code which checks other things, the list goes on. This would not be any problem in principle but I wanted a translation with optimized address range as usual so had to chase all offenders down. And theses checks are not in similar places in the licensed romsets: a Konami engineer back then created all new ones for each romset. Ugh.              Also emulating the actual raster hardware and vectorizing it was a lot more work than with Pooyan: not only has it twice the sprite data (at half color range) but quite a few are combined in multiple ways and drawn as larger elements - up to 4 sprites combined. These are also output depending upon the raster clipping and wrap-around capability: there is no sprite hw disable and they are just moved outside the clip area to remove them. So the 3-sprite cloud in the first level is partially drawn both left and right when it is positioned center-offscreen since the invisible width offscreen is just 32 pixels but the cloud is 48 pixels wide.         Talking about clouds: this game looks like it uses a lot of more sprites than the 24 in hardware. That a lot more are floating around is due to two ingenious ideas: first the background clouds/rocks are all multiplexed, meaning the screen is split into an upper and lower part and the cpu checks a scanline counter (no interrupts involved). And if the upper cloud has been displayed reprograms the position for the lower half, always half a screen away both in x and y. This multiplexing doubles the visible cloud sprites from 8 to 16.       The second trick is converting the play area's char buffer into a sprite lookalike buffer for the player shots: these are all characters and nothing else is (and can be) displayed via this buffer when used for shots. This is why during the intermission when the year is displayed the player can rotate the shipt. But cannot already shoot.      Both tricks are impressive to do in software for an early arcade game.          In the original game the top-most cloud layer is above the enemies and players and the other two below but since this is not possible on a vector display here all clouds have just been made dark. I think this works quite well, the feel of a parallax scrolling is there and by having them all quite a bit darker than the game elements you interact with they feel like background and not interfering (since they are still drawn visibly 'under' the enemies or player).                            "},
    { 0, 0, "                           Welcome to the vectorised version of the arcade game Space Pilot, a bootleg of Konami's Time Pilot.      The game is extremely similar to Time Pilot - only the necessary security checks have been either adapted or removed. And the logo graphics adapted. Badly adapted even, the 'SPACE' part has a different style to the unchanged 'PILOT' graphics. Even the KONAMI name is still there, at first I thought this was because the sprite graphics has not been blanked out (the game draws this both in characters but also with identical sprite data on top of these characters for whatever reason).  But no - it is blanked out in the Space Pilot graphics ROM so I guess the bootleggers could not be bothered to remove these chars...                      "},
    { 0, 0, "                           Welcome to the vectorised version of the 1982 arcade game Time Pilot, licensed to Atari by Konami.     The licensed version has a nicer attract - the UFO level is present here but absent in the original Konami attract - and a myriad of different security checks plus a marginally newer codebase. But other than that the game is the same as Konami's original.                            "},
    { 0, 0, "                           Welcome to the vectorised version of the 1982 arcade game Time Pilot, licensed to Centuri by Konami.     The licensed version has a nicer attract - the UFO level is present here but absent in the original Konami attract - and a myriad of different security checks plus a marginally newer codebase. But other than that the game is the same as Konami's original.                            "}
};