The MSX Channel

Olá galera;

 

Um canal de música voltado ao MSX.

 

http://www.youtube.com/user/TheMSXChannel

 

Deem uma olhada lá, vale a pena.

 

[]´s

Dexter

Expansor de slots para MSX – Parte 2

Olá Pessoal;

Um dos recursos mais úteis que existem para MSX e que chama a atenção é sobre a possibilidade de expansão, mas devido a limitação utilizamos o expansor de slots.

EXPANSOR DE SLOTS PARA MSX

Na maioria dos micros do padrão MSX contamos com 2 slots, como se pode ver abaixo;

 

A idéia desse projeto é construir esse expansor utilizando componentes básicos e baratos facilmente encontrados no mercado.

 

 

Continua….

MINI ONE CHIP MSX – MOCM

Olá galera;

A comunidade mundial de MSX esta realmente aquecida, agora um site coreano recentemente divulgou, e esperamos que não seja nenhum vaporware;

FOTO DA PLACA DO MOCM

MOCM – VISTA DE CIMA

Para quem quiser acompanhar o projeto recomendo que acessem o site; http://kpark.co.kr/2925329 , apesar de ser um site coreano, dá pra entender diretinho com o auxílio de um tradutor.

Dá para ver claramente;

• Slot para cartucho;
• 2 portas para joystick;
• Leitor de cartões SD;
• 1 Porta VGA;
• Altera Cyclone;
• E alguns outros componentes que ainda não identifiquei com precisão.

E vamos acompanhando para ver se aparece mais novidades, assim vamos aqueçendo o mercado do MSX;

[]´s

Dexter

Placa de Rede no MSX

Olá pessoal;

O que parecia improvável a alguns anos aconteceu, e felicidade da comunidade de MSX, apresento-lhes a OBSONET;

Vista frontal da obsonet 2 – aberta, dá pra ver o chip da realtek rtl8019as usado no projeto.

Usando o comando eth i

Realizando um ping da msx.org

Aplicando o comando inl v

É por tudo isso que podemos ver que a obsonet realmente é um projeto fantástico,  e finalmente o msx não esta mais sozinho

Este é um projeto interessante que podemos fazer e divulgar para toda comunidade.

Para quem curte desenvolver suas placas pretendo em breve demonstrar aqui como construir essa placa.

Até +

Dexter

Estendendo os limites do MSX

Olá pessoal;

Após o fim do MSX, muitas pessoas consideraram o fato do MSX parar de ser fabricado não significava necessariamente o fim.

Motivados por seu amor pela plataforma, bem como por um senso de desafio, alguns programadores resolveram estender os limites conhecidos, estudando a arquitetura a fundo e escrevendo softwares que realizavam tarefas antes inimagináveis neste computador.

Um destes projetos é o Uzix, que é um sistema operacional Unix desenvolvido para MSX pelo brasileiro Adriano da Cunha. Este sistema operacional é um clone do Unix (assim como o Linux) e implementa quase todas as funcionalidades, inclusive acesso à internet.

Uzix – Desenvolvido por um brasileiro, alias temos excelentes desenvolvedores aqui !

Outro sistema interessante é o SymbOS, que é um sistema operacional gráfico (estilo Windows) que roda tanto no MSX quando no Amstrad CPC.

Que tal jogar um PAC Man dentro de um sistema operacional de janelas, multitarefa no MSX !!!

Em sua ultima versão o msx é capaz de fazer coisas inimagináveis, confira o video abaixo e tire suas conclusões.

 

 

Também é possivel ver seu poder de multiprocessamento usando um MMC nesse vídeo;

 

 

[]´s

Dexter

A história do MSX – Parte 6

ONE CHIP MSX

Vista frontal da placa One Chip MSX

O One Chip MSX é um projeto bem interessante, onde uma empresa japonesa desenvolveu uma versão do MSX que roda em apenas um chip FPGA.

O One Chip MSX é um MSX1 e MSX2 completo, com entradas para cartucho e cartão SD, que pode ser usado para copiar os programas de MSX do PC e vice-versa.

O One Chip MSX é produzido pela D4 Enterprise e foi vendido fora do Japão pela Bazix.
O 1Chip MSX (tb conhecido como ESE MSX 3 System) como já foi descrito acima é um chip construído para ser uma versão compacta e expansível do microcomputador MSX. Mais especificamente o MSX 2.

Com um único chip FPGA contendo toda a parte eletrônica (exceto a memória RAM) de um MSX2, incluindo o MSX-MUSIC e a extensão de áudio SCC+.

O sistema está dentro de um compartimento azul plástico transparente e pode ser usado com um monitor comum (ou na própria tv)e um teclado de pc.Há slots para os tradicionais cartuchos (games ou não) de MSX bem como o cartão de SD e os cartões de memória MMC como um meio de armazenamento externo.

 

Vista superior do One Chip MSX

Mesmo não precisando de um disk drive de 3/1/2 (disquetes), os discos são suportados pela emulação em um cartão de memória, inclusive o suporte para inicializar o MSX-DOS. Devido ao seu Hardware Programável VHDL, é possível fornecer ao dispositivo uma nova extensão de hardware simplesmente rodando um programa de reconfiguração usando o MSX-DOS.

O “One Chip MSX” vem equipado com 2 conectores USB que podem ser usados depois dando suporte ao código VHDL.

O ESE MSX System 3 é projetado pela ESE Artists’ Factory e distribuído com o nome de “One Chip MSX” pela D4 Entrepise e foi encarregado de ser distríbuido fora do Japão pela empresa Bazix. Contudo devido a algumas regulamentações na Europa,não pode ser distribuída naquele continente em sua forma original. O mercado europeu teve que esperar por uma versão adaptada que seria produzida e distribuída pela Bazix na Europa. Por fim a Bazix deixou de ser representante da MSX Association e assim não trará o One Chip MSX ao mercado ocidental.

Continua…

Adaptador de teclado PS2 para MSX – Parte 14

Olá Pessoal;

Segue os primeiros códigos do nosso programa;

Programa [main.c]

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Projeto: CONVERSOR DE TECLADO/MOUSE PS2 PARA MSX *
* MSXRevival *
* Dexter *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* REVISAO: 22/03/2012 *
* Definição das variaveis usadas *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Rotinas de definicoes de LCD e PIC utilizado *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include <D:\Projetos\MSX\Teclado e Mouse PS2 para MSX\main.h>
#include <D:\Projetos\MSX\Teclado e Mouse PS2 para MSX\lcd.c>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Programa Principal *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void main()
{

// Inicializa o LCD
lcd_init();
// x = coluna
// y = linha
lcd_gotoxy(1,1);
printf(lcd_putc,”XXXXXXXXXXXXXXXX”);
lcd_gotoxy(1,2);
printf(lcd_putc,”XXXXXXXXXXXXXXXX”);

while(true)
{

delay_ms(3000); // Aguarda 3 segundos
lcd_init();
lcd_gotoxy(4,1);
printf(lcd_putc,”MSXREVIVAL”);
lcd_gotoxy(2,2);
printf(lcd_putc,”CONVERSOR PS/2″);
delay_ms(3000);
lcd_init();
lcd_gotoxy(5,1);
printf(lcd_putc,”PROJETOS”);
lcd_gotoxy(2,2);
printf(lcd_putc,”ELETRONICOS-MSX”);

}
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Fim do Programa *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

Programa [main.h]

#include <16f628a.h>
#include <stdio.h>

#FUSES NOWDT //No Watch Dog Timer
#FUSES HS //Internal RC Osc
#FUSES INTRC //Internal RC Osc
#FUSES NOPUT //No Power Up Timer
#FUSES NOPROTECT //Code not protected from reading
#FUSES NOBROWNOUT //No brownout reset
#FUSES MCLR //Master Clear pin enabled
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD //No EE protection

#use delay(clock=8000000)  //Velocidade

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Fim do Programa *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

E finalmente o driver que controla nosso LCD.

Programa [ lcd.c ]

///////////////////////////////////////////////////////////////////////////////
//// LCD.C ////
//// Driver for common LCD modules ////
//// ////
//// lcd_init() Must be called before any other function. ////
//// ////
//// lcd_putc(c) Will display c on the next position of the LCD. ////
//// The following have special meaning: ////
//// \f Clear display ////
//// \n Go to start of second line ////
//// \b Move back one position ////
//// ////
//// lcd_gotoxy(x,y) Set write position on LCD (upper left is 1,1) ////
//// ////
//// lcd_getc(x,y) Returns character at position x,y on LCD ////
//// ////
//// CONFIGURATION ////
//// The LCD can be configured in one of two ways: a.) port access or ////
//// b.) pin access. Port access requires the entire 7 bit interface ////
//// connected to one GPIO port, and the data bits (D4:D7 of the LCD) ////
//// connected to sequential pins on the GPIO port. Pin access ////
//// has no requirements, all 7 bits of the control interface can ////
//// can be connected to any GPIO using several ports. ////
//// ////
//// To use port access, #define LCD_DATA_PORT to the SFR location of ////
//// of the GPIO port that holds the interface, -AND- edit LCD_PIN_MAP ////
//// of this file to configure the pin order. If you are using a ////
//// baseline PIC (PCB), then LCD_OUTPUT_MAP and LCD_INPUT_MAP also must ////
//// be defined. ////
//// ////
//// Example of port access: ////
//// #define LCD_DATA_PORT getenv(“SFR:PORTD”) ////
//// ////
//// To use pin access, the following pins must be defined: ////
//// LCD_ENABLE_PIN ////
//// LCD_RS_PIN ////
//// LCD_RW_PIN ////
//// LCD_DATA0 ////
//// LCD_DATA1 ////
//// LCD_DATA2 ////
//// LCD_DATA3 ////
//// LCD_DATA4 ////
//// ////
//// Example of pin access: ////
//// #define LCD_ENABLE_PIN PIN_E0 ////
//// #define LCD_RS_PIN PIN_E1 ////
//// #define LCD_RW_PIN PIN_E2 ////
//// #define LCD_DATA0 PIN_D4 ////
//// #define LCD_DATA1 PIN_D5 ////
//// #define LCD_DATA2 PIN_D6 ////
//// #define LCD_DATA3 PIN_D7 ////
//// ////
///////////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996,2009 Custom Computer Services ////
//// This source code may only be used by licensed users of the CCS C ////
//// compiler. This source code may only be distributed to other ////
//// licensed users of the CCS C compiler. No other use, reproduction ////
//// or distribution is permitted without written permission. ////
//// Derivative programs created using this software in object code ////
//// form are not restricted in any way. ////
///////////////////////////////////////////////////////////////////////////

typedef struct
{ // This structure is overlayed
BOOLEAN enable; // on to an I/O port to gain
BOOLEAN rs; // access to the LCD pins.
BOOLEAN rw; // The bits are allocated from
BOOLEAN unused; // low order up. ENABLE will
int data : 4; // be LSB pin of that port.
#if defined(__PCD__) // The port used will be LCD_DATA_PORT.
int reserved: 8;
#endif
} LCD_PIN_MAP;

#if defined(__PCB__)
// these definitions only need to be modified for baseline PICs.
// all other PICs use LCD_PIN_MAP or individual LCD_xxx pin definitions.
/* EN, RS, RW, UNUSED, DATA */
const LCD_PIN_MAP LCD_OUTPUT_MAP = {0, 0, 0, 0, 0};
const LCD_PIN_MAP LCD_INPUT_MAP = {0, 0, 0, 0, 0xF};
#endif

#ifndef LCD_ENABLE_PIN
#define lcd_output_enable(x) lcdlat.enable=x
#define lcd_enable_tris() lcdtris.enable=0
#else
#define lcd_output_enable(x) output_bit(LCD_ENABLE_PIN, x)
#define lcd_enable_tris() output_drive(LCD_ENABLE_PIN)
#endif

#ifndef LCD_RS_PIN
#define lcd_output_rs(x) lcdlat.rs=x
#define lcd_rs_tris() lcdtris.rs=0
#else
#define lcd_output_rs(x) output_bit(LCD_RS_PIN, x)
#define lcd_rs_tris() output_drive(LCD_RS_PIN)
#endif

#ifndef LCD_RW_PIN
#define lcd_output_rw(x) lcdlat.rw=x
#define lcd_rw_tris() lcdtris.rw=0
#else
#define lcd_output_rw(x) output_bit(LCD_RW_PIN, x)
#define lcd_rw_tris() output_drive(LCD_RW_PIN)
#endif

#ifndef LCD_DATA_PORT
#if defined(__PCB__)
#define LCD_DATA_PORT 0×06 //portb
#define set_tris_lcd(x) set_tris_b(x)
#elif defined(__PCM__)
#define LCD_DATA_PORT getenv(“SFR:PORTB”) //portd
#elif defined(__PCH__)
#define LCD_DATA_PORT getenv(“SFR:PORTB”) //portd
#elif defined(__PCD__)
#define LCD_DATA_PORT getenv(“SFR:PORTB”) //portd
#endif
#endif

#if defined(__PCB__)
LCD_PIN_MAP lcd, lcdlat;
#byte lcd = LCD_DATA_PORT
#byte lcdlat = LCD_DATA_PORT
#elif defined(__PCM__)
LCD_PIN_MAP lcd, lcdlat, lcdtris;
#byte lcd = LCD_DATA_PORT
#byte lcdlat = LCD_DATA_PORT
#byte lcdtris = LCD_DATA_PORT+0×80
#elif defined(__PCH__)
LCD_PIN_MAP lcd, lcdlat, lcdtris;
#byte lcd = LCD_DATA_PORT
#byte lcdlat = LCD_DATA_PORT+9
#byte lcdtris = LCD_DATA_PORT+0×12
#elif defined(__PCD__)
LCD_PIN_MAP lcd, lcdlat, lcdtris;
#word lcd = LCD_DATA_PORT
#word lcdlat = LCD_DATA_PORT+2
#word lcdtris = LCD_DATA_PORT-0×02
#endif

#ifndef LCD_TYPE
#define LCD_TYPE 2 // 0=5×7, 1=5×10, 2=2 lines
#endif

#ifndef LCD_LINE_TWO
#define LCD_LINE_TWO 0×40 // LCD RAM address for the second line
#endif

BYTE const LCD_INIT_STRING[4] = {0×20 | (lcd_type << 2), 0xc, 1, 6};
// These bytes need to be sent to the LCD
// to start it up.
BYTE lcd_read_nibble(void);

BYTE lcd_read_byte(void)
{
BYTE low,high;

#if defined(__PCB__)
set_tris_lcd(LCD_INPUT_MAP);
#else
#if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
output_float(LCD_DATA0);
output_float(LCD_DATA1);
output_float(LCD_DATA2);
output_float(LCD_DATA3);
#else
lcdtris.data = 0xF;
#endif
#endif

lcd_output_rw(1);
delay_cycles(1);
lcd_output_enable(1);
delay_cycles(1);
high = lcd_read_nibble();

lcd_output_enable(0);
delay_cycles(1);
lcd_output_enable(1);
delay_us(1);
low = lcd_read_nibble();

lcd_output_enable(0);

#if defined(__PCB__)
set_tris_lcd(LCD_INPUT_MAP);
#else
#if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
output_drive(LCD_DATA0);
output_drive(LCD_DATA1);
output_drive(LCD_DATA2);
output_drive(LCD_DATA3);
#else
lcdtris.data = 0×0;
#endif
#endif

return( (high<<4) | low);
}

BYTE lcd_read_nibble(void)
{
#if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
BYTE n = 0×00;

/* Read the data port */
n |= input(LCD_DATA0);
n |= input(LCD_DATA1) << 1;
n |= input(LCD_DATA2) << 2;
n |= input(LCD_DATA3) << 3;

return(n);
#else
return(lcd.data);
#endif
}

void lcd_send_nibble(BYTE n)
{
#if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
/* Write to the data port */
output_bit(LCD_DATA0, BIT_TEST(n, 0));
output_bit(LCD_DATA1, BIT_TEST(n, 1));
output_bit(LCD_DATA2, BIT_TEST(n, 2));
output_bit(LCD_DATA3, BIT_TEST(n, 3));
#else
lcdlat.data = n;
#endif

delay_cycles(1);
lcd_output_enable(1);
delay_us(2);
lcd_output_enable(0);
}

void lcd_send_byte(BYTE address, BYTE n)
{
lcd_output_rs(0);
while ( bit_test(lcd_read_byte(),7) ) ;
lcd_output_rs(address);
delay_cycles(1);
lcd_output_rw(0);
delay_cycles(1);
lcd_output_enable(0);
lcd_send_nibble(n >> 4);
lcd_send_nibble(n & 0xf);
}

void lcd_init(void)
{
BYTE i;

#if defined(__PCB__)
set_tris_lcd(LCD_OUTPUT_MAP);
#else
#if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
output_drive(LCD_DATA0);
output_drive(LCD_DATA1);
output_drive(LCD_DATA2);
output_drive(LCD_DATA3);
#else
lcdtris.data = 0×0;
#endif
lcd_enable_tris();
lcd_rs_tris();
lcd_rw_tris();
#endif

lcd_output_rs(0);
lcd_output_rw(0);
lcd_output_enable(0);

delay_ms(15);
for(i=1;i<=3;++i)
{
lcd_send_nibble(3);
delay_ms(5);
}

lcd_send_nibble(2);
for(i=0;i<=3;++i)
lcd_send_byte(0,LCD_INIT_STRING[i]);
}

void lcd_gotoxy(BYTE x, BYTE y)
{
BYTE address;

if(y!=1)
address=LCD_LINE_TWO;
else
address=0;

address+=x-1;
lcd_send_byte(0,0×80|address);
}

void lcd_putc(char c)
{
switch (c)
{
case ‘\f’ : lcd_send_byte(0,1);
delay_ms(2);
break;

case ‘\n’ : lcd_gotoxy(1,2); break;

case ‘\b’ : lcd_send_byte(0,0×10); break;

default : lcd_send_byte(1,c); break;
}
}

char lcd_getc(BYTE x, BYTE y)
{
char value;

lcd_gotoxy(x,y);
while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low
lcd_output_rs(1);
value = lcd_read_byte();
lcd_output_rs(0);

return(value);
}

O resultado final nessa primeira etapa pode ser visto na figura abaixo;

Com essa primeira  etapa concluída, sabemos que nosso PIC pode se comunicar com um LCD 16×2 em 4 bits utilizando a linguagem C da qual utilizei o compilador CCS.

Vocês podem reparar que fiz algumas modificações para tornar o programa bem simples, quero manter a simplicidade do projeto ao máximo para que qualquer pessoa possa construir seu conversor/adaptador.

Nossa próxima etapa agora é coletar os dados digitados no teclado do PC (PS2) e apresenta-lo no LCD.

Até mais

[]´s

Dexter

Adaptador de teclado PS2 para MSX – Parte 13

Olá Pessoal;

Segue o primeiro esquema de ligação do PIC com o display de LCD.

Essa é a primeira parte das ligações das quais pretendo fazer para que o PIC se comunique com o display de LCD, agora o próximo passo é desenvolver o protocolo de comunicação que irá se encarregar de enviar os dados do PIC para o controlador do display, para que apareçam as mensagens no visor.

Você deve considerar que apesar de não demonstrado no desenho o PIC deve estar com os pinos 5 VSS (GND) e 14 VDD(5v) conectados adequadamente em sua protoboard.

Fiz um botão de reset apenas para demonstrar como o mesmo funciona, assim como adicionei um potênciometro que é responsável pelo controle de luminosidade do display, optei também por ligar um led de power.

Em princípio esse é o esquema básico que precisamos ter para conseguir o que queremos, e numa segunda etapa ligar o conector ps2 ao PIC para que possamos capturar o scancode e apresenta-lo no display.

[]´s

Dex

Continua…

Um pouco de diversão

 

Knightmare

 

Olá pessoal, hoje vamos falar de mais um grande clássico do MSX, e na minha opinião um dos melhores de sua época.

 

A história:
Afrodite, a deusa do amor e da beleza, foi aprisionada no Castelo dos Pesadelos do Demônio dos Subterrâneos… e resgatá-la é a tarefa do apaixonado herói Popolon.

Em uma longa jornada até o Castelo dos Pesadelos, Popolon já perdia as esperanças por não encontrá-la. Suas noites eram povoadas por terríveis pesadelos, com as terríveis criaturas que ameaçavam sua amada.

Uma noite, entretanto, Popolon teve um sonho diferente. Hera, irmã de Zeus, veio visitar seus sonhos e contou-lhe a localização do Castelo dos Pesadelos: além das escarpas do Monte Atos.

Hera deu-lhe ainda um conselho: para que usasse sabiamente as jóias que Afrodite lhe deixou pelo caminho, bem como os cristais mágicos enviados do Olimpo para que consiga encontrar e resgatar Afrodite.

Com sua esperança renovada e a proteção de Hera, Popolon partiu em direção ao Monte Atos… Conseguirá Popolon resgatar sua amada a tempo?

O jogo:

Knightmare foi criado em 1986 pela Konami com o rótulo de “Romantic Action Game” (termo dado aos jogos de ação cujo objetivo é salvar a sua amada). Foi graças a este jogo que a Konami consolidou-se de vez como a maior softhouse de games de MSX do Japão, mantendo-se fielmente no cargo até o fim da sua participação no mundo MSX em agosto de 1991.

Ao todo, o jogo tem 8 fases de ação ininterrupta e que vão fazer você pensar duas os três vezes antes de pegar os itens especiais durante o jogo. Após o final do jogo, você vai pra fase 9 – que é a fase 1 de novo – só que com um grau de dificuldade a mais, como os tiros dos inimigos que ficam mais rápidos e uma exigência maior de habilidade.

Gráficos:
Knightmare é um jogo de ação com scroll vertical e ângulo de visão superior. Seus gráficos são muito bons mesmo sendo para um simples MSX 1, o que mostra que a Konami sabia muito bem o que fazer com seus jogos. Tirar leite de pedra é uma regra que a softhouse fez no MSX e ainda faz até hoje. Todos os inimigos são visualmente bonitos e os movimentos são perfeitos.

As fases são um destaque à parte. Cada uma delas lhe coloca em situações diferentes que devem ser resolvidos rapidamente. A fase 7 (foto ao lado) por exemplo, deixa o jogador em desespero pois você tem que atirar para descobrir onde está a ponte ao mesmo tempo em que muitos fantasmas vermelhos ficam invisíveis quando você atira. É o famoso “se correr, o bicho pega, se ficar, o bicho come”.

 

Músicas e efeitos sonoros:
Outro ponto forte do jogo. As músicas de Knightmare são viciantes. Tudo bem que as principais são 6 (a do Play Start, as duas BGM que tocam durante as fases, a do final do jogo, a que o Popolon morre e o tema do Game Over), mas mesmo assim são muito bem feitas. Destaque para as BGMs. Elas são um pouco curtas, mas não tem como não se empolgar. Um trabalho muito bem feito da senhorita Miki Higashino, a responsável direta pelos temas do jogo não sairem da minha mente nos últimos 21 anos. Os efeitos sonoros também estão perfeitos. Tudo colocado milimimetricamente certo.

Jogabilidade:

Knightmare requer muita habilidade e precisão. Deve-se dosar muito bem qual arma usar, o quanto de velocidade deve ser adicionada ao Popolon e uma boa estratégia para acumular pontos. Com o tempo, você vai memorizando a sequência de como os inimigos aparecem, mas dependendo do seu progresso, a sequência muda e aí complica bastante. Mas nada que tire o brilho do jogo.

Conclusão:
Knightmare é um jogo viciante e empolgante. É uma mostra impecável do que se pode fazer com apenas 32kb de tamanho. Músicas excelentes, efeitos sonoros incríveis e um grau de dificuldade altamente desafiador a cada fase foram colocados neste jogaço na dosagem certa. É um jogo obrigatório pra quem possui um MSX em casa.

Um ano depois, em 1987, Knightmare ganhou uma continuação: Knightmare II – The Maze Of Galious. E a saga encerrou-se com o adventure Knightmare III – Shalom, de 1988. Mas falaremos deles mais tarde.

Macetes do jogo:
- Invencibilidade temporária:
Para ficar invencível temporariamente, segure as teclas Seta para Esquerda, Seta para Direita, SELECT e Y na tela-título. Mantenha as teclas pressionadas, mas solte e aperte SELECT – pra facilitar o trabalho. Assim que começar a fase, solte as teclas e aperte SELECT. Popoulon ficará invisível por 99 segundos, e pra voltar a ficar imune, pressione SELECT depois do tempo acabar. A imunidade não funcionará se você tocar no chefão da fase, morrer afogado ou ficar preso entre a tela e um obstáculo.

- 25 Vidas:
É o mesmo procedimento de ficar invencível, só que use a letra N em vez do Y.

- Usar os Cristais mais de uma vez:
Tente achar a jóia mágica que faz parar o tempo (a Rainha do xadrez em vermelho). Depois fique atirando até ouvir o som caratcerístico de que está acertando um dos Cristais de Armas ou de Poder. Pegue a Jóia Mágica ANTES do cristal aparecer na tela. Agora atire no cristal até você escolher sua arma. Depois do tempo acabar, o mesmo cristal vai aparecer de novo, mas com o jogo rolando.

- Saídas ocultas:
Em certos lugares das fases 1, 2, 3 e 4, dois blocos misteriosos escondem uma saída que levará o nosso herói para a próxima fase sem a necessidade de enfrentar o monstro no final dela. Geralmente, ele só aparece quando a fase é superada e depois de você perder o jogo.

Curiosidades:
- Em 1989, uma empresa brasileira chamada Forte II Games lançou para os fliperamas o jogo “Pesadelo“, que nada mais é do que o Knightmare hackeado e instalado num MSX 1 miniaturizado numa plaquinha com os três processadores.

 

[]´s

Dex

Fonte: Gagá Games,Cemetery Games

Expansor de Slots para MSX – Parte 1

Olá Pessoal;

Outro projeto que chama a atenção é a possibilidade de se realizar a expansão de slots, pois normalmente temos apenas dois encaixes.

Isso normalmente causa um desconforto para aqueles que desejam ligar outros dispositivos ao micro, pensando nessa possibilidade estarei iniciando aqui um projeto que visa construir esse expansor.

Continua…

Dex