Neste número: Includes em Turbo Pascal, Número 'e', Programação dos HOOKs, Programas Residentes, Trilha 0, Impressão Dupla, Programação Gráfica em SCREEN 1, Entrada pelo Teclado, Bubble Sort, Criptografia, Kinght Time, Thexder, Time Pilot, Who Dares Wins II, Army Moves, Exoide-Z, Gyrodine, Hyçer Rally, Trick Boy.
Includes no Turbo Pascal
Artigo Original: Antônio F.S.Shalders, Revisão: Wilson Pilon
Os módulos apresentados neste artigo serão de extrema utilidade para quem lida com funções trigonométricas, pois definem um grande número de funções trigonométricas derivadas e hiperbólicas, em dois subprogramas do tipo include.
Um include é um subprograma que é anexado ao programa principal e passa a fazer parte do mesmo.
Para podermos utilizar as novas funções em um determinado programa, devemos incluir, logo após o nome do programa, a linha de inclusão, como no exemplo:
programa teste;
{$i trg.p}
{$i hiper.p}
begin
...
end.Obviamente, devemos fazer o include que contiver as funções necessárias ao programa em questão.
O include TRG.P é referente às funções trigonométricas derivadas e inversas, o HIPER.P, às hiperbólicas e hiperbólicas inversas.
A função SGN(X), que fornece o sinal referente ao argumento, também foi incluída, pois é utilizada por algumas das novas funções.
Os argumentos deverão ser dados em radianos e os resultados são do tipo real.
Os programas rodam tanto nos sistemas derivados do MSX-DOS, como nos derivados do CP/M.
Se o include em questão possuir funções desnecessárias, basta deletá-las com control+Y. Caso contrário, a memória do micro estará sendo desperdiçada e, em caso de geração de um programa autoexecutável, este irá tornar-se muito grande.
Se os dois includes forem utilizados simultaneamente, a rotina FUNCTION relativa à função SGN(X) deverá ser deletada de um deles. Caso contrário, haverá erro.
Trigonométricas
function sec(a:real):real;
begin
sec:=1/cos(a);
end;
function csc(a:real):real;
begin
csc:=1/sin(a);
end;
function tan(x:real):real;
begin
tan:=sin(x)/cos(x);
end;
function ctg(a:real):real;
begin
ctg:=1/tan(a);
end;
function arcsin(a:real):real;
begin
arcsin:=arctan(a/sqrt(-a*a+1))
end;
function arccos(a:real):real;
begin
arccos:=-arctan(a/sqrt(-a*a+1))+(pi/2);
end;
function sgn(a:real):real;
begin
if a<0 then
sgn:=-1
else
sgn:=1
end;
function arcsec(x:real):real;
begin
arcsec:=arctan(x/sqrt(x*x+1))+sgn(sgn(x)-1)*(pi/2);
end;
function arccsc(x:real):real;
begin
arccsc:=arctan((x/sqrt(x*x-1))+sgn(x)-1)*(pi/2);
end;
function arcctg(x:real):real;
begin
arcctg:=arctan(x)+(pi/2);
end;Hiperbólicas
function sgn(a:real):real;
begin
if a< then
sgn:=-1
else
sgn:=1;
end;
function hypsin(x:real):real;
begin
hypsin:=(exp(x)-exp(-x))/2;
end;
function hypcos(x:real):real;
begin
hypcos:=(exp(x)+exp(-x))/2;
end;
function hyptan(x:real):real;
begin
hyptan:=exp(-x)/exp(x)+exp(-x)*2+1;
end;
function hypsec(x:real):real;
begin
hypsec:=2/(exp(x)+exp(-x));
end;
function hypacs(x:real):real;
begin
hypacs:=2/(exp(x)-exp(-x));
end;
function hypctg(x:real):real;
begin
hypctg:=exp(-x)/(exp(x)-exp(-x))*2+1;
end;
function hyparcsin(x:real):real;
begin
hyparcsin:=ln(x+sqrt(x*x+1));
end;
function hyparccos(x:real):real;
begin
hyparccos:=ln(x+sqrt(x*x-1));
end;
function hyparctan(x:real):real;
begin
hyparctan:=ln((1+x)/(1-x))/2;
end;
function hyparcsec(x:real):real;
begin
hyparcsec:=ln(sqrt(-x*x+1)+1)/x;
end;
function hyparccsc(x:real):real;
begin
hyparccsc:=ln(sgn(x)*sqrt(x*x+1)+1)/x;
end;
function hyparcctg(x:real):real;
begin
hyparcctg:=ln((x+1)/(x-1))/2;
end;Descobrindo o Número 'e'
Artigo Original: Pierluigi Piazzi, Revisão: Wilson Pilon
O MSX não trabalha com logaritmos decimais (base 10), mas apenas com logaritmos naturais (ou neperianos) de base e.
Para você saber qual o valor aproximado do número e, basta lembrar que:
e=e1=EXP(1)
Portanto, ao digitar:
PRINT EXP(1)
você obterá o valor de ''e'' que, fornecido em dupla precisão pelo MSX, deverá dar
2.7182818284588
A finalidade deste artigo é mostrar de onde surge um número tão esquisito e que ele não é tão 'arbitrário' quanto parece.
Afinal, se podemos escolher a base que o computador usa, por que não optar por um número mais simples?
Para ter uma ideia de que este número não é arbitrário, acompanhe o raciocínio a seguir:
Imagine que você vai ao Banco fazer um investimento que renda 100% ao cabo de um ano. Vamos supor, obviamente, que a gente resida num país normal, destituído de marajás e, portanto, livre de inflação. Receber 100% de juros ao cabo de um ano é um 'negocião'. Afinal, seu capital fica, no fim do período, multiplicado por 2!
O banco onde você faz o investimento permite a opção de receber 50% por semestre. É a mesma coisa?
Óbvio que não, seu capital é multiplicado por 1.5 no fim do primeiro semestre e, novamente, por 1.5 no fim do segundo semestre. Você terá, no fim do ano, seu capital multiplicado por:
1.5 * 1.5 = 2.25
e não apenas 2, como no caso anterior.
Dividir tanto o período quanto a taxa de juros por 2 não produz o mesmo resultado final.
Com os olhos brilhando de cobiça, você solicita uma taxa de juros de 25% (100%/4) por trimestre (ano/4).
Neste caso, seu capital ficará multiplicado por:
1.25 * 1.25 * 1.25 * 1.25
Como os cálculos ficam mais complicados, você começa a usar seu MSX para descobrir o resultado, digitando:
PRINT (1.25)^4
e percebe que seu capital ficará multiplicado por 2.44140625!
Nesta altura, já fazendo um programinha para descobrir de quanto vai enriquecer se o banco pagar 100%/12 ao mês:
PRINT (1+1/12)^12
Oba! O capital fica multiplicado por 2.6130352902232!
Vislumbrando lucros infinitos, você pede ao gerente para dividir a taxa de juros e o período por um número N, tão grande quanto você queira.
Será que há um limite para tudo isso? Para descobrir, digite o programa da listagem 1, que permite calcular de quanto fica multiplicado seu capital, aumentando indefinidamente N (a cada cálculo, vamos multiplicar N por 10 para fazê-lo crescer rapidamente).
Rodando este programa, você deve obter os resultados mostrados abaixo.
Como você notou, o crescimento, mesmo usando uma taxa de juros praticamente instantânea, é limitado e este limite é, justamente, o número 'e'.
Esta característica de limite de um crescimento instantâneo é que dá ao 'e' propriedades tão interessantes a ponto de elegê-lo como um dos números mais importantes da matemática!
Tão importante que o sistema operacional do MSX acha muito mais fácil (e rápido) calcular funções exponenciais e logaritmos usando-o como base.
Se você quiser calcular um logaritmo em outra base, porém, basta lembrar a propriedade:
logBA = logeA/logeB
Para calcular, por exemplo, o logaritmo de um número A, na base B, no BASIC MSX basta usar esta propriedade como mostra o exemplo da listagem 2.
Para finalizar, voltando ao problema dos juros intantâneos, você pode digitar o programa da listagem 3 e aprenderá alguma coisa útil, não só em relação ao número 'e', mas também à técnica de construção dos gráficos em BASIC MSX, como mostra a figura abaixo.
100 SCREEN 0:KEY OFF
110 N=1
120 PRINT" N";
130 PRINT TAB(21);"(1+1/n)^n":PRINT
140 FOR I=1 TO 14
150 C=(1+1/N)^N
160 PRINT N;TAB(21);
170 PRINT USING"#.#############";C
180 N=N*10
190 NEXT I
200 PRINT:PRINT TAB(18);"e=";EXP(1)10 DEF FN LD(A,B)=LOG(A)/LOG(B)
20 INPUT "Qual o numero";A
30 INPUT "Qual a base";B
40 Z=FN LD(A,B)
50 PRINT"O Logaritmo de:";A
60 PRINT"na base :";B
70 PRINT"vale :";Z100 SCREEN 2:Z=174
110 OPEN"grp:" AS#1:W=10000
120 FOR L=0 TO 19
130 LG=170-8*L
140 PRESET(16,LG-3)
150 PRINT#1,USING"#.####";2.7168+L/W
160 LINE(64,LG)-(234,LG)
170 NEXT L
180 FOR C=0 TO 10
190 CG=64+17*C
200 LINE(CG,170)-(CG,18)
210 IF C\4 =C/4 THEN PRESET(CG-4,Z): PRINT#1,3+C/4:PRESET(CG-17,181): PRINT#1,10:LINE(CG,173)-(CG,170)
220 NEXT C
230 PRESET(240,164):PRINT#1,"N"
240 PSET(64,170)
250 FOR I=3 TO 5.5 STEP .0625
260 E=(1+(1/(10^I)))^(10^I)
270 X=64+68*(I-3)
280 Y=170-((E-2.7168)*8*10000)
290 LINE-(X,Y)
300 NEXT I
310 PRESET(240,48):PRINT#1,"e"
320 GOTO 320O incrível HOOK
Artigo Original: André L.F.de Freitas, Revisão: Wilson Pilon
Os micros MSX possuem uma área de memória RAM reservada para uso do sistema. Lá são encontradas variáveis do sistema utilizadas pelo BIOS (Basic Input Output System) e pelo interpretador BASIC. Não confundir este tipo de variável com as variáveis que podemos ter no BASIC. As variáveis de sistema tem posição fixa na memória e são de acesso exclusivo do sistema MSX, podendo o usuário lê-las ou escrevê-las somente através de PEEKs e POKEs ou utilizando linguagem de máquina, mas sabendo muito bem o que faz, pois o uso indevido destas variáveis pode confundir todo o sistema ocasionando resultados imprevisíveis. Após a área de variáveis de sistema, temos uma seção de memória, mais precisamente entre os endereços &HFD9A e &HFFC9, que, se observarmos com um monitor assembly, perceberemos estar preenchida com bytes &HC9 (instrução RET do assembly Z80). Dividindo esta região em grupos de 5 bytes, podemos chamar cada grupo destes de HOOK (vou usar aqui a palavra da língua inglesa, pois as traduções geralmente se tornam sem sentido). A princípio pode parecer que a área de memória preenchida com RETs não tem importância nenhuma, mas, no caso do MSX, estes Hooks são de grande utilidade.
O BIOS e o BASIC MSX chamam, em alguns pontos de sua execução, endereços nesta área de memória. Lá, encontram um RET e retornam à origem sem executar nada. É o caso dos comandos de Disk BASIC e a própria rotina de leitura de teclado. Podemos, então, colocar nestes pequenos Hooks, também, pequenas rotinas para chamar outras áreas da memória, criando um salto a partir de rotinas do sistema que estavam em ROM e, portanto, não poderiam ser modificadas, conseguindo, desta forma modificar o próprio sistema operacional.
Cinco bytes são mais que suficientes para conter uma instrução CALL, seu endereço correspondente, e um RET no final para a volta ao sistema operacional. É assim que funcionam os comandos do Disk BASIC. Desta forma, podemos ter extensões do BASIC ou do BIOS sem a necessidade de alteração na ROM do equipamento.
Como exemplo de utilização dos Hooks, os POKEs que forneço a seguir vão alterar um Hook que é chamado pela rotina de impressão de caracteres no vídeo, fazendo uma chamada à rotina do BEEP do BASIC MSX a cada caracter impresso no vídeo. A ordem em que os POKEs são dados, do último para o primeiro endereço, é necessária para o Hool não ficar com os bytes &HC3, &HC9, &HC9, após o primeiro POKE, o que causaria um salto para &HC9C9.
Exemplo:
POKE &HFDA5,&HC0
POKE &HFDA6,&H00
POKE &HFDA4,&HCD
Experimente, agora, digitar alto, entrar um programa em BASIC e dar um LIST depois, ou qualquer coisa que produza caracteres no vídeo. Repare no BEEP a cada impressão e na velocidade com que os caracteres são apresentados, que é bem menor que a normal devido à chamada da rotina do BEEP. Para voltar ao normal, basta um POKE &HFDA4,&HC9, que restaura o Hook ao original. É esta a utilidade dos Hooks: permitir o desvio de rotinas do sistema para outras rotinas criadas por você mesmo ou já existentes no micro. É uma forma simples de se expandir o sistema MSX por software, sem nenhuma alteração no equipamento.
No desenvolvimento do MSX, foram reservados 5 bytes para cada Hook, sendo estes criados de forma a aproveitar as rotinas mais fundamentais do funcionamento do MSX, permitindo futuras alterações. O porquê dos cinco bytes é o seguinte: permitir a inclusão no Hook de uma chamada a rotinas em qualquer slot, feito da forma descrita abaixo:
Exemplo RST 30h:
RST 30h ;1 byte
DEFB [ID de slot] ;1 byte
DEFW [Endereço Execução] ;2 bytes
RET ;1 byte| Endereço | HOOK | Desvio para | Endereço | HOOK | Desvio para |
|---|---|---|---|---|---|
| FD9A | HKEYI | 0C4A Interrupção de teclado | FEA3 | HEOF | 6D33 Instrução EOF |
| FD9F | HTIMI | 0C53 Interrupção de teclado | FEA8 | HFPOS | 6D43 Instrução FPOS |
| FDA4 | HCHPU | 08C0 Rotina CHPUT (imp.caractere) | FEAD | HBAKU | 6E36 Instrução LINE INPUT# |
| FDA9 | HDSPC | 09E6 Mostra cursor | FEB2 | HPARD | 6F15 Análise de dispositivos |
| FDAE | HERAC | 0A33 Apaga o cursor | FEB7 | HNODE | 6F33 Análise de dispositivos |
| FDB3 | HDSPF | 0B2B Rotina DSPFNK (mostra funções) | FEBC | HPOSD | 6F37 Análise de dispositivos |
| FDB8 | HERAF | 0B15 Rotina ERAFNK (apaga funções) | FEC1 | HDEVN | HOOK NÃO USADO |
| FDBD | HTOTE | 0842 Rotina TOTEXT (tela texto) | FEC6 | HGEND | 6F8F Funções de I/O |
| FDC2 | HCHGE | 10CE Rotina CHGET (le caracter) | FECB | HRUNC | 629A Run/Clear |
| FDC7 | HINIP | 071E Copia Tabela de chr.p/ VDP | FED0 | HCLEA | 62A1 Run/Clear |
| FDCC | HKEYC | 1025 Decodificador de teclado | FED5 | HLOPD | 62AF Run/Clear |
| FDD1 | HKEYA | 0F10 Decodificador de teclado | FEDA | HSTKE | 62F0 Inicialiação do STACK |
| FDD6 | HNMI | 1398 Interrupções não mascaráveis | FEDF | HISFL | 145F Rotina ISFLIO (direção de buffer) |
| FDD8 | HPINL | 23BF Rotina PINL (input) | FEE4 | HOUTD | 1B46 Rotina OUTDO (saída em dispositivo) |
| FDE0 | HQINL | 23CC Rotina QINL (input) | FEE9 | HCRDO | 7328 Saída de CR e LF em OUTDO |
| FDE5 | HINLI | 23D5 Rotina INLIN (input) | FEEE | HDSKC | 7374 Entrada de linhas em buffer |
| FDEA | HONGO | 7810 Instrução ON DEVICE GOSUB | FEF3 | HDOGR | 593C Traçado de linhas |
| FDEF | HDSKO | 7C16 Instrução DSKO$ | FEF8 | HPRGE | 4039 Fim de Programa |
| FDF4 | HSETS | 7C1B Instrução SET | FEFD | HERRP | 40DC Rotina de Erros |
| FDF9 | HNAME | 7C20 Instrução NAME | FF02 | HERRF | 40FD Rotina de Erros |
| FDFE | HKILL | 7C25 Instrução KILL | FF07 | HREAD | 4128 OK na execução |
| FE03 | HIPL | 7C2A Instrução IPL | FF0C | HMAIN | 4134 Execução de programas |
| FE08 | HCOPY | 7C2F Instrução Copy | FF11 | HDIRD | 41A8 Execução de comandos |
| FE0D | HCMD | 7C39 Instrução CMD | FF16 | HFNI | 4237 Fim de execução |
| FE12 | HDSKF | 7C3E Instrucão DSKF | FF1B | HFINE | 4247 Fim de execução |
| FE17 | HDSKI | 7C43 Instrução DSKI$ | FF20 | HCRUN | 42B9 Conversão em TOKENS |
| FE1C | HATTR | 7C48 Instrução ATTR$ | FF25 | HCRUS | 4353 Conversão em TOKENS |
| FE21 | HLSET | 7C4D Instrução LSET | FF2A | HISRE | 437C Conversão em TOKENS |
| FE26 | HRSET | 7C52 Instrução RSET | FF2F | HNTFN | 43A4 Conversão em TOKENS |
| FE2B | HFIEL | 7C57 Instrução FIELD | FF34 | HNOTR | 44EB Conversão em TOKENS |
| FE30 | HMKI$ | 7C5C Instrução MKI$ | FF39 | HSNGF | 45D1 Instrução FOR |
| FE35 | HMKS$ | 7C61 Instrução MKS$ | FF3E | HNEWS | 4601 NEW em execução |
| FE3A | HMKD$ | 7C15 Instrução MKD$ | FF43 | HGONE | 4646 Execução de programas |
| FE3F | HCVI | 7C66 Instrução CVI | FF48 | HCHRG | 4666 Rotina CHGCTR (pega caracter) |
| FE44 | HCVS | 7C6B Instrução CVS | FF4D | HRETU | 4821 Instrução RETURN |
| FE49 | HCVD | 7C70 Instrução CVD | FF52 | HPRTF | 4A5E Instrução PRINT |
| FE3E | HGETP | 6A93 Localiza FCB | FF57 | HCOMP | 4A94 Instrução PRINT |
| FE53 | HSETF | 6AB3 Localiza FCB | FF5C | HFINP | 4AFF Instrução PRINT |
| FE58 | HNOFO | 6AF6 Instrução OPEN | FF61 | HTRMN | 4B4D Erro em READ/INPUT |
| FE5D | HNULO | 6B0F Instrução OPEN | FF66 | HFPME | 4C6D Avaliador de expressões |
| FE62 | HNTFL | 6B3B Fecha Buffer I/O | FF6B | HNTPL | 4CA6 Avaliador de expressões |
| FE67 | HMERG | 6B63 Instrução MERGE/LOAD | FF80 | HEVAL | 4DD9 Avaliador de Fatores |
| FE6C | HSAVE | 6BA6 Instrução SAVE | FF75 | HOKNO | 4F2C Avaliador de Fatores |
| FE71 | HBINS | 6BCE Instrução SAVE | FF7A | HFING | 4F3E Avaliador de Fatores |
| FE76 | HBINL | 6BD4 Instrução MERGE/LOAD | FF7F | HISMI | 51C3 Execução de programas |
| FE7B | HFILE | 6C2F Instrução FILES | FF84 | HWIDT | 51CC Instrução WIDTH |
| FE80 | HDGET | 6C3B Instrução GET/PUT | FF89 | HLIST | 522E Instrução LIST |
| FE85 | HFILO | 6C51 Saída Sequêncial | FF8E | HBUFL | 532D Covnersão de TOKENS em texto |
| FE8A | HINDS | 6C79 Entrada Sequêncial | FF93 | HFRQI | 543F Conversão para inteiros |
| FE8F | HRSLF | 6CD8 Instrução INPUT$ | FF98 | HSCNE | 5514 Número de linhas p/ponteiros |
| FE94 | HSAVD | 6D03 Instrução LOC 6D25 InstruçãoEOF 6D39 Instrução FPOS 6D14 InstruçãoLOF | FF9D | HFRET | 67EE Limpa STRINGS |
| FE99 | HLOC | 6D0F Instrução LOC | FFA2 | HPTRG | 5EA9 Procura de variáveis |
| FE9E | HLOF | 6D20 Instrução LOF | FFA7 | HPHYD | 148A Rotina PHIDIO (disco) |
| FFAC | HFORM | 148E Rotina FORMAT (disco) | |||
| FFB1 | HERRO | 406F Rotina de erros | |||
| FFB6 | HLPTO | 085D Rotina LPTOUT (impressora) | |||
| GGBB | HLPTS | 0884 Rotina LPTTST (impressora) | |||
| FFC0 | HSCRE | 79CC Instrução SCREEN | |||
| FFC5 | HPLAY | 73E5 Instrução PLAY |
Programas Residentes
Artigo Original: André L.F.de Freitas, Revisão: Wilson Pilon
Em algumas outras linhas de microcomputadores muito comuns no mercado internacional, sendo estes favbicados também aqui no Brasil, encontramos um tipo de software muito interessante. São programas que, ao serem carregados, aparentemente nào exercem função alguma, retornam ao sistema operacional apresentando, somente, uma mensagem do tipo: Pressione as teclas X e Y simultaneamente para executar.
De fato, são programas extremamente interessantes, pois ficam na momória do micro sem aparecer ao usuário e, ao serem chamados através de um conjunto de teclas, interrompem qualquer processo que o micro esteja executando e assumem o controle, oferecendo ao usuário recursos como redefinição de teclado, calculadora, agenda, etc..
Mais interessante é saber como estes programas ficam 'pendurados' no sistema sem atrapalhar o processamento normal do micro.
O princípio é o seguinte: os processadores comumente encontrados em microcomputadores possuem modos em que podem ser interrompidos, desviando o processo corrente para uma outra rotina, executando a esma e retornando ao processo anterior. No caso do MSX, isto é feito pelo hardware 60 vezes por segundo, gerando a interrupção de leitura do teclado. É desta forma que o teclado do MSX é varrido e o código da tecla encontrado. Basado em interrupções deste tipo, surgiu o software 'terminate and stay resident', que podemos chamar de software residente.
O program, inicialmente, é carregado para a memória e uma pequena rotina é colocada estrategicamente dentro da rotina que é chamada pela interrupção. Esta rotina fica acompanhando a leitura do teclado, aguardando o determinado conjunto de teclas. Este conjunto, ao ser digitado, gera um salto para o programa na memória e este se encarrega de guardar informações a respeito do processo que o micro estava executando. Após esta operação, o programa residente é normalmente executado e, ao ser terminado, restaura todo o processo anteriormente executado pelo micro, prosseguindo do ponto onde parou.
O objetivo deste artigo é mostrar ao usuário MSX como fazer o mesmo com o seu micro, aproveitando aquela memória RAM que não é normalmente utilizada pelo MSX. Atente para o fato de não ser fornecido um programa residente como os encontrados no mercado para outros micros, mas somente um pequeno programa que irá limpar a tela e imprimir uma mensagem. O que eu quero é mostrar o processo pelo qual o programa residente é instalado e, futuramente, chamado pelo teclado.
A listagem 1 contém o programa residente e seu instalador, que é encontrado a partir de seu endereço inicial de execução até o seu final.
O instalador vai transportar o programa residente do local onde foi carregado para um slot de RAM livre no MSX. A seguir, transportará para uma área livre no final da memória RAM (temos uma área não utilizada entre os endereços &HFCCA e &HFFFF) uma rotina que testará se a tecla <ESC> foi pressionada e decidirá, caso sim ou não, respectivamente, se chama o programa residente ou retorna sem nada executar.
O terceiro passo será alterar o HOOK do sistema correspondente à leitura de teclado (Hook HKEYG - interrupção de teclado) para um desvio para aquele programa instalado no fim da RAM. Está pronta a instalação do programa residente. Para aqueles que não sabem ainda o que são os Hooks, sugiro procurar informações em outro artigo de minha autoria publicado neste número de CPU.
Muito cuidado para não digitar códigos errados, pois isto pode ocasionar a perda de controle do sistema e ser necessário pressionar o famigerado botão de RESET do micro para retornar ao sistema, perdendo-se todo trabalho feito até então. É uma boa ideia salvar o programa, antes, para não perder alguns fios de cabelo (chato não?).
De posse do conhecimento de todas as informações encontradas neste e no outro artigo, fica ao usuário a tarefa de criar seu programa residente e substituir o exemplo dado pelo próprio. Experimente, também, tentar alterar a rotina de teste de teclado para um outro código de teclas a acionar o programa residente.
Outra coisa a lembrar é não chamar o programa residente se você estiver trabalhando fora da SCREEN 0, pois este programa residente não prevê a restauração de outro modo de tela a não ser o modo 0.
Futuramente, publicarei programas residentes que poderão ser substituídos pelo fornecido por este artigo, como, por exemplo, uma calculadora ou uma tabela de códigos ASCII, que serão muito úteis instalados no micro durante o desenvolvimento de outros programas, mesmo que você só programe em BASIC. Aguarde outros artigos da série.
1000 ' REVISTA CPU - JUNHO 88
1010 ' PROGRAMAS RESIDENTES
1020 ' A.L. FREITAS
1030 '
1040 ' CODIGOS DO PROG. RESIDENTE
1050 '
1060 DATA C5,D5,E5,2A,DC,F3,E5,21
1070 DATA 00,00,11,00,50,01,BF,03
1080 DATA CD,59,00,CD,C3,00,21,04
1090 DATA 01,22,DC,F3,21,41,40,7E
1100 DATA FE,00,28,06,CD,A2,00,23
1110 DATA 18,F5,CD,9F,00,21,00,50
1120 DATA 11,00,00,01,BF,03,CD,5C
1130 DATA 00,E1,22,DC,F3,E1,D1,C1
1140 DATA C9,2A,2A,2A,2A,2A,2A,2A
1150 DATA 2A,2A,2A,2A,2A,2A,2A,2A
1160 DATA 2A,2A,2A,2A,2A,2A,2A,2A
1170 DATA 2A,2A,2A,2A,2A,2A,2A,2A
1180 DATA 2A,2A,2A,2A,2A,2A,2A,2A
1190 DATA 2A,0D,0A,0A,09,09,52,45
1200 DATA 56,49,53,54,41,20,43,50
1210 DATA 55,0D,0A,0A,09,09,4A,55
1220 DATA 4E,48,4F,20,38,38,0D,0A
1230 DATA 0A,09,09,50,52,4F,47,52
1240 DATA 41,4D,41,53,20,52,45,53
1250 DATA 49,44,45,4E,54,45,53,0D
1260 DATA 0A,0A,09,09,41,2E,4C,2E
1270 DATA 20,46,52,45,49,54,41,53
1280 DATA 0D,0A,0A,0A,09,09,50,52
1290 DATA 45,53,53,49,4F,4E,45,20
1300 DATA 55,4D,41,20,54,45,43,4C
1310 DATA 41,0D,0A,0A,09,09,50,41
1320 DATA 52,41,20,53,41,49,52,2E
1330 DATA 0D,0A,0A,0A,2A,2A,2A,2A
1340 DATA 2A,2A,2A,2A,2A,2A,2A,2A
1350 DATA 2A,2A,2A,2A,2A,2A,2A,2A
1360 DATA 2A,2A,2A,2A,2A,2A,2A,2A
1370 DATA 2A,2A,2A,2A,2A,2A,2A,2A
1380 DATA 2A,2A,2A,2A,0D,0A,00
1390 '
1400 ' CODIGOS DO PROG. INSTALADOR
1410 '
1420 DATA F5,C5,D5,E5,CD,6C,00,21
1430 DATA A2,D0,11,CA,FF,01,22,00
1440 DATA ED,B0,DB,A8,32,FD,FF,21
1450 DATA 00,40,06,03,DB,A8,C6,04
1460 DATA 32,FE,FF,D3,A8,3E,AA,77
1470 DATA 56,2F,77,5E,7A,83,FE,FF
1480 DATA 28,0C,10,E8,3A,FD,FF,D3
1490 DATA A8,E1,D1,C1,F1,C9,21,00
1500 DATA C0,11,00,40,01,07,01,ED
1510 DATA B0,3A,FD,FF,D3,A8,21,CA
1520 DATA FF,22,D2,FD,3E,CD,32,D1
1530 DATA FD,21,6C,D0,7E,FE,00,28
1540 DATA 06,CD,A2,00,23,18,F5,E1
1550 DATA D1,C1,F1,C9,0D,0A,0A,54
1560 DATA 45,43,4C,45,20,5B,45,53
1570 DATA 43,5D,20,50,41,52,41,20
1580 DATA 41,54,49,56,41,52,0D,0A
1590 DATA 50,52,4F,47,52,41,4D,41
1600 DATA 20,52,45,53,49,44,45,4E
1610 DATA 54,45,2E,2E,2E,07,0D,0A
1620 DATA 0A,00,FE,3A,C0,E5,CD,56
1630 DATA 01,3E,C9,32,D1,FD,3A,FE
1640 DATA FF,D3,A8,CD,00,40,3A,FD
1650 DATA FF,D3,A8,3E,C3,32,D1,FD
1660 DATA E1,3E,04,C9
1670 ' CARREGADOR DE CODIGOS
1680 ' PARA MEMORIA
1690 '
1700 CLS: KEY OFF: WIDTH 40
1710 FOR I=&HC000 TO &HC106
1720 READ A$: A=VAL("&H"+A$)
1730 POKE I,A
1740 NEXT I
1750 FOR I=&HD000 TO &HD0C3
1760 READ A$: A=VAL("&H"+A$)
1770 POKE I,A
1780 NEXT I
1790 PRINT"PARA INSTALAR:": PRINT
1800 PRINT"DEF USR=&HD000": PRINT
1810 PRINT"A=USR(0)"A Trilha 0
Artigo Original: Gonçalo R.F.Murteira, Revisão: Wilson Pilon
Com o início da comercialização dos drives para a linhas MSX, um novo horizonte foi aberto para os usuários desta linha de equipamentos.
A operação com disco não oferece dificuldade de tipo algum, possuindo comando simples e de fácil assimilação.
Podemos dizer que a trilha 0 é a alma do disquete e, por esta razão, resolvemos fornecer maiores informações sobre esta parte vital do disco para que você tenha maiores condições para resolver os problemas que lhe venham a aparecer, tal como recuperar um arquivo deletado acidentalmente.
Após formatarmos um disco no MSX-DOS, o mesmo será dividido conforme ilustra a tabela abaixo.
| Dados | Face Simples | Face Dupla |
|---|---|---|
| Número de Trilhas | 40 | 40 |
| Número de setores por trilha | 9 | 9 |
| Número de setores por disquete | 360 | 720 |
| Número de setores disponíveis | 351 | 708 |
| Número de setores reservados | 9 | 12 |
| Número de setores do boot | 1 | 1 |
| Número de setores do FAT | 4 | 4 |
| Número de setores do diretório | 4 | 7 |
Às vezes, ao formartarmos um disco, pode acontecer que não obtenhamos a capacidade total de armazenamento. Quando isto ocorre, é porque o computador, ao efetuar a verificação da formatação, encontrou alguma trilha não apta para uso, eliminando-a para que não se venha a ter surpresas no futuro.
Pode ocorrer que o dano no disco ocorra na trilha 0, fazendo com que não se possa utilizar mais aquele disco. Um exemplo prático desta situação é quando tentamos obter o diretório de um disco formatado e conseguimos a mensagem de erro de entrada e saída.
O Diretório
O diretório está alocado na trilha 0, no setores de 5 a 8, caso o disco esteja formatado em face simples, ou nos setores de 5 a 8 do lado 0 e de 0 a 2 do lado 1, caso a formatação do disco seja de face dupla.
Como já é conhecido, os micros da linha MSX e IBM-PC são compatíveis a nível de organização de disco. Devido a esta particularidade, algumas informações disponíveis no diretório do MSX não são utilizadas, como é o caso do atributo de hora de gravação.
Ao formartarmos um disco, definimos, também, o espaço fixo reservado para o diretório. Este espaço é de 7 setores para os discos de face dupla ou de 4 setores para formatação em face simples.
Cada setor tem capacidade para armazenar 512 bytes. Portanto, o diretório pode armazenar até 112 nomes de arquivos em discos de face dupla ou 64 em discos de face simples.
Assim sendo, se você possuir 112 arquivos gravados em um disco de face dupla, mesmo que ainda exista espaço disponível, você não conseguirá gravar o programa 113, pois não haverá mais espaço disponível no diretório para o armazenamento das informações referentes aquele arquivo. Neste caso, você será informado pelo sistema operacional através da mensagem diretório cheio.
Proteção de Programas
No IBM-PC temos a facilidade de poder proteger um programa contra os olhares dos curiosos e, assim, tentar evitar a cópia.
Para fazermos o mesmo no MSX, basta mudarmos o byte referente ao atributo para qualquer valor entre 04H e 07H.
Com este procedimento, o programa poderá ser lido, mas não aparecerá se for solicitado o diretório do disco.
Recuperação de Programas
Pode acontecer que, acidentalmente, você apague um arquivo e deseje recuperá-lo. Se, após apagar um arquivo, você não tiver efetuado nenhuma gravação no disco, poderá recuperá-lo, pois o comando que apaga um arquivo simplesmente troca o primeiro caractere do nome por E5H.
Para recuperarmos o arquivo basta trocarmos novamente o primeiro caractere pelo código original.
Sobre a trilha 0 de um disco ainda existe muito para se falar e ela será tema de outros artigos de edições futuras.
Impressão Dupla
Artigo Original: J.L.Fonseca, Revisão: Wilson Pilon
Você já deve ter tido a necessidade de efetuar o reforço de um texto impresso.
A rotina que apresentamos foi baseada em um programa publicado no livro '100 Dicas para MSX', na página 120, da Editora Aleph, no qual efetuamos alterações.
O programa permite que o usuário selecione o número de colunas e o número de vezes que a cabeça de impressão deverá efetuar um reforço do texto, imprimindo novamente os pontos já impressos.
Portanto, com este programa, você pode fazer com que as suas listagens ou textos sejam impressos com mais qualidade e contraste.
O efeito obtido é diferente de uma impressão em qualidade de carta, na qual cada ponto é impresso duas vezes, mas havendo um ligeiro espaçamento entre cada ponto.
115 SCREEN 0:CLEAR 200,&HE000
116 PRINT:PRINT:PRINT
117 PRINT"Caracteres por Linha ";
118 INPUT C
119 IF C<1 OR C>255 THEN GOTO 116
120 PRINT"Numero de Passagens ";
121 INPUT P
122 IF P<1 OR P>255 THEN GOTO 1200
123 FOR K=&HE000 TO &HE073
124 READ A$:POKE K,VAL("&h"+A$)
125 NEXT K
126 POKE &HE022,C
127 POKE &HE045,P
128 DEFUSR=&HE066
129 I=USR(0)
1000 DATA F5,C5,D5,E5,DD,E5,DD,21
1010 DATA 65,E0,FE,0D,28,4D,FE,0A
1020 DATA 28,13,06,00,DD,4E,00,21
1030 DATA 66,E0,09,03,DD,71,00,77
1040 DATA 79,FE,00,20,36,3E,C9,32
1050 DATA B6,FF,0E,00,DD,46,00,78
1060 DATA B0,28,15,21,66,E0,7E,CD
1070 DATA A5,00,23,10,F9,3E,0D,CD
1080 DATA A5,00,0C,79,FE,00,20,E4
1090 DATA 3A,65,E0,B7,3E,0A,C4,A5
1100 DATA 00,0E,00,DD,71,00,3E,C3
1110 DATA 32,B6,FF,DD,E1,E1,D1,C1
1120 DATA F1,33,33,B7,C9,00,F3,21
1130 DATA 00,E0,22,B7,FF,3E,C3,32
1140 DATA B6,FF,FB,C9,00,FF,00,FFProgramação Gráfica em SCREEN 1
Artigo Original: Sílvio Chan, Revisão: Wilson Pilon
Que tal fazer gráficos instantâneos em uma tela texto?
A princípio, você deve estar pensando que estou propondo algo impossível. Não nego que você esteja parcialmente correto. No entanto, o que este artigo pretende ensinar, não é nada menos do que uma das técnicas mais utilizadas na confecção de telas e cenários gráficos nos jogos em Assembly, os quais você certamente deve ter em casa.
A principal vantagem desta técnica é a rapidez com que as telas são desenhadas. Esta técnica se baseia na criação de blocos gráficos que podem ser coloridos com as cores do MSX. No nosso caso, a criação destes blocos será feita em SCREEN 1, que é uma tela de texto do MSX.
Para compreender o modo como são criados os blocos, é preciso entender o funcionamento das tabelas de formas dos caracteres e de cores do SCREEN 1, já que os blocos serão formados através da alteração do desenho de cada caractere. Isto significa que podemos criar, nada menos, do que 255 tipos diferentes de blocos.
O desenho de cada caractere é armazenado na tabela de forma em grupos de oito bytes. Sua extensão é de 2 Kb.
A tabela de cores armazena em um byte a cor de um grupo de oito caracteres.
Como no MSX existem 256 caracteres, esta tabela possui a extensão de 32 bytes. O valor contido em cada um destes bytes é calculado pela seguinte fórmula:
V=16*CE+CF
onde CE é a cor de frente e CF é a cor de fundo.
Para livrar os leitores do trabalho de calcular os endereços e respectivos valores, este artigo é acompanhado de um programa muito eficiente para a criação de blocos gráficos.
Após digitá-lo, salve-o e execute.
O Programa
Ao rodar o programa o micro lhe perguntará se você deseja carregar um banco de blocos ou se deseja ir direto para o editor. Caso já exista um banco de blocos na memória, também surgirá a opção para poder utilizá-lo. Em seguida aparecerá um menu. Para efetuar a escolha da opção desejada, você deverá utilizar a seta para baixo e posicionar a barra de espaço na opção desejada.
Depois de ter editado o seu banco, salve-o. Para recomeçar o programa, pressione [F1] e, para sair, [F2].
Para utilizar um banco já gravado, digite BLOAD '<nome_do_banco>',r. Após o carregamento, os caracteres serão automaticamente modificados, devido a uma rotina em Assembly existente no final do program que faz exatamente isto.
Com o banco já carregado na memória, basta usar a instrução PRINT para imprimir os blocos desejados (caracteres) na tela.
Caso você mude acidentalmente de tela, basta digitar:
DEFUSR=&HE813:A=USR(0)
ou
DEFUSR=&HD813:A=USR(0)
para quem estiver utilizando disco.
Programas criados para manipular o banco de caracteres, como por exemplo jogos, aplicativos e adventures, deve ter suas extensões calculadas para não apagarem o banco.
Os usuários de disco devem efetuar as seguintes alterações:
Linha 90 - alterar o valor das variáveis E1, E2, E3 e E4 para &HD000, &HD82E, &HD813 e &HD7F1, respectivamente.
Linha 150 - troque &HE0 por &H00 e &HE7 por &HD7.
O programa passa da área de disco, rodar em K7 ou ajustar endereços.
Máximas e Mínimas
Artigo Original: J.L.Fonseca, Revisão: Wilson Pilon
Na coluna de hoje, vamos falar sobre um problema que muitas vezes nos aparece quando o nosso programa exige uma entrada de dados pelo teclado.
Muitas vezes o usuário digita algo errado e o programa, ao tentar usar o dado errado, para com uma mensagem de erro.
Ora, um programa não deve parar devido a erros na entrada, devendo, em vez disso, fazer um crítica da entrada e dar ao usuário a oportunidade de dar a entrada correta.
Temos dois tipos distintos de entradas com que nos preocupamos: as numéricas e as alfanuméricas. No primeiro caso, devemos verificar se o valor fornecido está dentro da faixa permitida para o mesmo no programa. No segundo caso, devemos verificar o comprimento da string.
Em qualquer dos casos é uma boa idéia apresentar na tela o campo onde se dará a entrada com algum tipo de caracter, como o ponto, por exemplo, para indicar o número de posições possíveis, não devendo ser possível ao usuário sair do campo.
Este tipo de preocupação pode parece excesso de cuidado, mas é, na verdade, um modo simpático de guiar a pessoa que está usando o programa pela primeira vez, além de tornar mais difícil que uma entrada errada se infiltre e pare o seu programa com uma mensagem de erro, que, em geral, não explica muito sobre a causa.
No MSX temos vários comandos e funções que nos ajudam nesta tarefa. Para a entrada de dados, temos a função INKEY$ que nos permite fazer a crítica de cada caractere à medida que o mesmo é digitado. Podemos, por exemplo, não aceitar a digitação de letras num campo numérico ou não permitir que um campo alfanumérico tenha mais que o comprimento permitido.
Muitos leitores já devem estar reclamando que a função INKEY$ só permite a entrada para variáveis alfanuméricas e, assim mesmo, só de um caractere por vez. No entanto, esta aparente desvantagem é a sua principal virtude, pois, assim, nos permite editar a entrada e, nos casos de valores numéricos testar a sua validade ao nível de cada dígito sem o perigo de erros de formato ou de valor.
Como exemplo, damos, a seguir duas listagens de rotinas de entrada de dados: uma para números inteiros e outra para cadeias de caracteres.
Estas rotinas não são as melhores ou mais eficientes, mas servem para dar uma ideia do que é possível fazer, indicando o caminho para quem quiser usá-las na sua forma original ou modificadas de modo a se adaptarem melhor à aplicação em uso.
Múltipla Escolha
Artigo Original: Carlos E.A.Moreira, Revisão: Wilson Pilon
A ideia desta seção surgiu com o aparecimento de compiladores de outras linguagens para MSX. Já encontramos com facilidade pelo menos um compilador da linguagem C e um compilador da linguagem Pascal para o MSX.
Aqui, mostraremos um método de ordenação que, apesar de não ser muito rápido, é bem simples e funcional para a maioria dos casos. O método é o 'bubble sort', ou seja, ordenação tipo bolha, tendo surgido o nome da comparação do método em que os valores a serem ordenados sobem a lista de valores com o fato de uma bolha subir à superfície da água (estranho, não é mesmo?). A rotina de ordenação é apresentada em BASIC, PASCAL e C, não tendo esta seção o objetivo de ensinar qualquer uma destas linguagens, mas, somente, apresentar rotinas para o usuário selecionar aquela que mais se enquadrar ao seu conhecimento. Bom proveito!
O algoritmo é o seguinte: a lista é pesquisada do início ao final. Cada vez que um valor mais alto da lista se encontra numa posição baixa, este é deslocado, trocando com o seguinte. O método se repete até que toda a lista esteja ordenada.
Bubble Sort em BASIC
Devem ser passadas as variáveis ITEM (Vetor a Ordenar) e CONT (Número de Elementos)/
Bubble Sort em PASCAL
Na definição de variáveis devem estar definidas: a ,b, tem, conta do tipo integer e item: array do tipo inteiro, real, etc..
Bubble Sort em C
Seguindo a estrutura da linguagem C, apresento uma função para ordenação.
A variável item é um ponteiro para um vetor interno. count é uma variável inteira contando o número de elementos do vetor. Estes valores devem ser passados para a função na sua chamada.
10 CLEAR:DEFINTA-Z:COUNT=10:DIM ITEM(COUNT):CLS:COLOR15,1,1:KEYOFF
20 FOR F=1 TO COUNT:ITEM(F)=RND(-TIME)*100:NEXTF
30 FOR F=1 TO COUNT:PRINT ITEM(F);";";:NEXTF
40 PRINT:T=TIME:PRINT "TIME=0":GOSUB 1000:PRINT:PRINT"TIME: ";TIME-T
50 FOR F=1 TO COUNT:PRINT ITEM(F);";";:NEXTF
60 PRINT:PRINT"Pressione [ENTER]":A$=INPUT$(1)
70 END
1000 REM BUBBLE SORT
1010 REM MSX SYSTEMS
1020 REM DEVEM SER PASSADAS AS SEGUINTES
1030 REM VARIAVEIS A ESTA ROTINA:
1040 REM ITEM - VETOR A ORDERNAR
1050 REM CONT - NO. DE ELEMENTOS
1060 REM
1070 FOR A%=1 TO COUNT-1
1080 FOR B%=COUNT-1 TO A STEP -1
1090 IF ITEM(B%)>ITEM(B%+1) THEN SWAP ITEM(B%),ITEM(B%+1)
1100 NEXT B,A
1110 RETURN
var
a,b,temp,conta: integer;
item: array[1..20] of integer;
for a:=1 to conta-1 do
for b:=1 to conta-1 downto a do
if(item[b] > item[b+1]) then
begin
temp:=item[b];
item[b]:=item[b+1];
item[b+1]:=temp;
end;void bubble(item,count)
int count, *item;
{
int a,b,t;
for(a=1:a<count;++a)
{
for(b=count-1;b>item[b])
{
t=item[b-1];
item[b-1]=item[b];
item[b]=t;
}
}
}Matemágica
Artigo Original: J.L.Fonseca, Revisão: Wilson Pilon
Na coluna deste mês, vamos nos dedicar a uma área que é uma das mais fascinantes dentro da matemática recreativa, a criptografia.
A criptografia é uma atividade tão antiga quanto a necessidade de transmitir mensagens secretas com segurança. No entanto, só com o advento dos computadores ela atingiu o destaque e a sofisticação que goza hoje em dia.
Embora os melhores sistemas de hoje sejam implementados em computadores caros ou até em circuitos eletrônicos dedicados, o seu MSX pode ser de grande valia no estudo e uso das técnicas mais simples ou quando a velocidade não é um fator primordial.
Vamos, pois, apresentar aqui algumas técnicas básicas de cifragem, isto é, a transformação de uma mensagem em linguagem comum para uma já codificada segundo um código pré-estabelecido.
O primeiro método que vamos ver é o da Listagem 1. Este método, um dos mais antigos, é conhecido como a cifra de Cesar, pois foi usado pelo mesmo nas comunicações com as suas legiões. O mesmo consiste em substituir cada letra por uma sequência que facilite o processo de codificação e decodificação.
Na forma aqui implementada, o programa pede uma mensagem a codifica ou decodificar, a qual será guardada em A$, e um deslocamento, que pode variar de 0 a 127. Ele pergunta, também, se você deseja codificar ou decodificar a mensagem. O deslocamento é um número que define como os caracteres serão substituídos. Por exemplo, se o deslocamento for igual a 3, a letra 'a' será substituída pela letra 'd', a 'b' pela 'e', e assim por diante. Na decodificação usamos o processo inverso.
Este método sofre a desvantagem de ser facilmente decifrável por quem não conhece o deslocamento, o que o torna pouco seguro e, por isso, desaconselhável para codificar mensagens com informações mais sigilosas.
Uma família de técnicas mais avançadas e mais seguras usa uma propriedade de função XOR, que faz com que um valor passado a esta função por duas vezes, com o mesmo argumento, não se altere. Para exemplificá-la, damos a listagem 2 que é um dos modos menos sofisticados de usar esta função na criptografia, mas, que por ser simples, exemplifica bem o uso da função.
Este programa pede a mensagem a codificar ou decodificar que será guardada em A$ e a chave que será guardada em C$. Na hora de imprimir o resultado, podem acontecer coisas estranhas, tais como não aparecer nada ou limpar a tela. Isto se deve ao fato de que os caracteres gerados podem ser códigos de controle. No entanto, quando usado em arquivos, este fato não cria problemas e é até útil, pois dificulta a decodificação dos mesmos.
Por hoje, não vamos nos alongar mais, mas voltaremos a este tema fascinante em colunas posteriores.
Até à próxima e bom divertimento.
40 'ROTINA 1
50 '
55 CLS
60 LINE INPUT "Entre com a Mensagem: "; A$
70 INPUT "Entre com o deslocamento: "; DE
80 INPUT "Codifica ou Decodifica? C/D"; C$
90 PRINT A$
100 B$=""
110 IF C$="D" OR C$="d" THEN GOTO 140
120 FOR I=1 TO LEN(A$): D$=MID$(A$,I,1):A=ASC(D$)+DE:B$=B$+CHR$(A):NEXT I
130 GOTO 150
140 FOR I=1 TO LEN(A$): D$=MID$(A$,I,1):A=ASC(D$)-DE:B$=B$+CHR$(A): NEXT I
150 PRINT B$40 ' rotina 2
50 '
55 CLS
60 LINE INPUT "Entre com a mensagem: ";A$
70 LINE INPUT "Encre com a chave: ";C$
80 PRINT A$
90 S$=""
100 FOR I=1 TO LEN(A$): J=(I MOD LEN(C$))+1: D$=MID$(A$,I,1):E$=MID$(C$,J,1):S$=S$+CHR$(ASC(D$)XOR ASC(E$)):NEXT I
110 PRINT S$Knight Tyme
Artigo Original: CPU, Revisão: Wilson Pilon
Knight Time é um dos melhores adventures existentes para o MSX, sendo, na realidade, uma continuação do jogo Spellbound, onde você foi transportado para bordo de uma nave no século XXV e irá tentar voltar para o seu tempo, convencendo os Senhores do Tempo a mandá-lo de volta.
Estas dicas irão auxiliar, mas, antes, você deverá ter algum trabalho.
A primeira coisa a ser feita é retirar o manto de invisibilidade e soltar todas as coisas que estiver carregando em um lugar seguro. Feito isto, vá para a sala do transportador e peça ajuda ao Derby IV. Ele deixará cair um cartão de identificação que você deve pegar.
Para validar seu cartão de identificação, você deverá ir para a ponte e pegar os Mactablets do Sarab, os quais aumentarão a sua força. A seguir, pegue o filme instantâneo com o Gordon e vá para a sala de recreação. Apanhe a câmera e o filme. Encontre o S3E3, dê-lhe a câmera e o filme e peça-lhe ajuda. Ele irá tirar a sua fotografia. Peque a fotografia e a cola. Se você fez tudo nesta ordem, a foto colará no cartão de identificação, o qual você poderá passar a utilizar.
Os personagens, agora, dar-lhe-ão atenção e você poderá comandar a nave estelar. Para fazer isto, você precisa do mapa estelar. Pegue o anúncio com o Sharon e deixe-o cair no local onde se encontra o mapa e a caneca do chopp. Você pode, agora, subir no anúncio e pegar o mapa. Pegue o mapa, a caneca e o anúncio e vá para a ponte. Dê o mapa estelar para o Gordon e você poderá dirigir a nave.
Você deve consertar a nave. Vá para a Starbase 1, via Polaris. Dê a caneca de chopp para o Gordon e peça-lhe ajuda. Ele irá consertar o transportador para você. A seguir, comunique-se com a Starbase 1, pedindo ajuda, e você receberá algumas coordenadas válidas. De posse das características, deça para a Starbase e inicie a exploração.
Use o mapa que fornecemos para marcar os seus movimentos pelos planetas.
Os pedaços do relógio do Sol de Alpha estão com Murphy e Hooper. Você irá encontrar Murphy no planeta Retreat e Hooper em Monopole. Os Senhores do Sol poderão ser encontrados em Outpost.
Objetos Úteis
- Bomba de Quartzo: Explode Planetas
- Botas: Para Passar os Sistemas de Segurança
- Saco de Batatas: Dê para Murphy
- Máscara de Gás: Protege-o Contra Gás
- Espelho: Mostra o que Você está Carregando
Códigos do Transportador
- Coordenadas da Nave: X0Y0Z0
- Starbase: X1Y2Z3
- Retreat: X8Y4Z1
- Monopole: X1Y8Z4
- Outpost: X8Y9Z6
Dicas
Artigo Original: CPU, Revisão: Wilson Pilon
Thexder
Inimigos Paralizados0 POKE &HFFFF,((PEEK(&HFFFF) XOR &HFF)AND &HF0)*1.0625
1 CLS:KEYOFF:CLEAR200,&HE68E
10 COLOR15,1,1:SCREEN2
150 BLOAD"THEXDE1"
151 POKE &H90E4,0
152 POKE &HA112,0
153 POKE &HABA4,0
154 DEFUSR=&HD000:A=USR(0)
160 BLOAD"THEXDE2",R
Time Pilot
Vidas Eternas10 BLOAD"timepilo.bin",R
20 REM POKE &HBF01,&HCB
30 REM POKE &H8848,&H0
40 REM DEFUSR=&Hc800 : A=USR(0)
Who Dares Wins II
Vidas Infinitas10 BLOAD"whodares.bin":POKE &H8493,&HFF:DEFUSR=&HDA01:FORN=1TO2500:NEXT:A=USR(0)
Army Moves I e Army Moves II
Obs: Para ir direto para a parte 2 do jogo, o código de acesso é 37215.!
Vidas Infinitas10 KEYOFF:CLEAR200,36000!:COLOR15,1,1:SCREEN2:A$="ARMY1-"
11 BLOAD"army1.bin",R
12 POKE54474!,201:BLOADA$+"1.bin",R
14 BLOADA$+"2.bin":CLEAR 200,51000!
16 BLOAD"ARMY1-3.BIN"
17 POKE &H88AB,0
18 DEFUSR=&H82DC:A=USR(0)10 KEYOFF:CLEAR200,36000!:COLOR15,1,1:SCREEN2:A$="ARMY2-"
11 BLOAD"army1.bin",R
12 POKE54474!,201:BLOADA$+"1.bin",R
14 BLOADA$+"2.bin":CLEAR 200,51000!
16 BLOAD"ARMY2-3.BIN"
17 POKE &H88AB,0
18 DEFUSR=&H82DC:A=USR(0)
Exoide Z
Vidas Infinitas5 REM POKE-1,170
10 BLOAD"exoide.bin"
20 POKE &H9923,0
30 DEFUSR=PEEK(&HFCC0)*256+PEEK(&HFCBF)
40 A=USR(0)
Gyrodine
Imunidade Total5 REM POKE-1,170
10 BLOAD"gyrod1.mc"
11 POKE -25648,0
12 DEFUSR=PEEK(&HFCC0)*256+PEEK(&HFCBF)
13 A=USR(0)
20 BLOAD"gyrod2.mc",R
Hyper Rally
Sem Inimigos10 BLOAD"hrally.bin"
20 POKE &H8B5B,0:POKE &H8B5C,1
30 DEFUSR=&HC800
40 A=USR(0)
Trick Boy
Várias Bolas1 BLOAD"TRICKBOY.BIN"
2 POKE &H93AA,99
3 DEFUSR=PEEK(&HFCC0)*256+PEEK(&HFCBF)
4 A=USR(0)
openMSX
- cpu-02.dsk: Executar Disco com os programas (MSX1).
- cpu-02cont.dsk: Executar Disco com programas adicionais (MSX1).
Download
- cpu-02.dsk: Disco com os programas.
- cpu-02cont.dsk: Disco com mais programas da revista.
- cpu-02.cas: Fita com as versões K7 dos programas.
- cpu-02gercar.cas: Cassete com o programa gráficos na SCREEN 1.
- cpu-02asc.zip: Arquivos em formato ASCII para leitura.
- Rcpu-02.pdf: PDF Resumido com índice.
- CPU_MSX_02.pdf: PDF Original MSX Livros.
Links
- MSX2.ORG: Revistas CPU MSX no site WWW.MSX2.ORG.