--==[ PARTE 10 ]==--Para obter os programas mencionados neste tutorial, por favor baixe o zip com a versão antiga do tutorial, neste link.
Nota: Aqui é o Snowman. Esse é o tutorial 10, e 10 é um número muito importante. Para os humanos normais, esse é o primeiro número maior que zero que precisa de dois dígitos para representar. (é claro que para nós, programadores DE VERDADE, é 16, mas não se pode esperar que seus pais entendam esse tipo de coisa).
De qualquer modo, eu decidi fazer uma forma diferente de converter esses tutoriais. Denthor e eu construímos uma linha de comunicação amigável. Desse modo, vou começar a colocar meus dois centavos onde eu quiser (apontando os erros de Denthor sempre que puder, sejam eles reais ou imaginários). A menos que o Denthor decida dar uma volta e reeditar todos os tutoriais, não há como ele responder a qualquer coisa que eu disser, então eu vou ganhar sempre. muhahahaaa!
Eu acabei de checar, e há cerca de 210k de código fonte convertido de Pascal pra C++. 210k! Você sabe o que essa digitação toda pode fazer para uma pessoa? Tem ideia de quantas vezes fiquei acordado até 5 da manhã trabalhando em uma dessas coisas? Bem, estou cansado de deixar o Denthor ter toda a glória. Está bem. A partir do tutorial 10, sou agora o “conversor depravado”, e vou fazer o melhor pra que essa série ficar o mais ‘interessante’ o posível.
-Christopher (Snowman) G. Mann / HORNET r3cgm@dax.cc.uakron.edu
[A propósito: Qualquer coisa entre colchetes foi adicionado pelo Snowman]
<A propósito: Qualquer coisa entre esses <> são coisas do Denthor, maquiadas>
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Introdução
Uau! O treinamento finalmente chegou na parte 10! Essa será também a primeira parte introduzida simultaneamente em BBS’s locais e na INTERNET! Sim, pessoal, eu coloquei uma cópia dos tutoriais anteriores em vários ftp sites, e esperei os flames, dizendo que os gurus da rede já sabiam essas coisas, e que eu estava gastando espaço à toa! Os flames não apareceram (bem, exceto um), e eu recebi algumas mensagens dizendo para continuar, então daqui pra frente eu vou uploadear todos os tutoriais futuros em ftp sites também (wasp.eng.ufl.edu, cs.uwp.edu, etc). Eu vou também deixar uma nota nos grupos da USENET comp.lang.pascal e comp.sys.ibm.pc.demos quando uma nova parte estiver terminada (até que as pessoas digam para parar;-))
Eu posso também ser contactado pelo meu novo endereço de email: smith9@batis.bis.und.ac.za
Bem, esse tutorial é sobre Chain-4. Quando me pediram para fazer um tutorial sobre Chain-4, senti que estaria caminhando em terras muito viajadas (eu já vi muitos treinamentos sobre esse assunto), mas as pessoas que me pediram, disseram que não tinham visto nenhum, então eu poderia fazer um? Quem sou eu pra dizer não?
[Eu, pessoalmente, sei que o Denthor não recebeu email nenhum pedindo para ele fazer um tutorial de Chain-4. Ele só está tentando aparecer.]
O programa de amostra anexado não é tão legal, mas tenho certeza de que todas as pessoas aí fora podem imediatamente ver o potencial que o Chain-4 carrega.
[Até onde o código vai, devo perguntar: // onde está isso? ]
Se você gostaria de me contactar, ou ao time, há muitos modos que você pode
fazê-lo: 1) Escrever uma mensagem para Grant Smith/Denthor/Asphyxia em email privado na ASPHYXIA BBS.
2) Escrever para Denthor, Eze ou Goth na Connectix.
3) Escrever para:
Grant Smith
P.O.Box 270 Kloof
3640
Natal
4) Ligar para mim (Grant Smith) no número (031) 73 2129
(deixe uma mensagem se você ligar quando eu estiver na faculdade)
Ligue para +27-31-73-2129 se você está ligando de fora da África do Sul (A conta é sua ;-))
5) Escreva para smith9@batis.bis.und.ac.za
OBS1 : Se você é um representante de uma companhia ou BBS e quer que a ASPHYXIA faça um demo para você, mande um email pra mim; podemos discutir.
OBS2 : Se você fez/tentou fazer um demo, MANDE PARA MIM! Estamos nos sentindo muito solitários e queremos encontrar/ajudar/trocar código com outros grupos de demos. O que você tem a perder? Mande uma mensagem aqui e podemos ver como transferir. Nós realmente queremos ouvir de você.
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
O que é Chain-4?
Vocês aí têm placas de vídeo de pelo menos 256k. A maioria de vocês têm placas de 512k, e alguns têm placas de 1Mb (by Krull: HAHAHAHAHAHA! desculpa, mas eu tinha que rir desses números :-D). Mas o que você vê na sua tela, como discutido em treinamentos anteriores, só tem 64k de dados! O que aconteceu com os outros 192k??? Chain-4 é um método de usar todos os 256k de uma vez.
[Mas é difícil usar os outros 192k?]
Ah, não, é simples! 1 tela = 64K. 64k * 4 = 256k. Então, Chain-4 permite você escrever em até 4 telas, enquanto mostra uma delas. Você pode se mover por essas 4 telas para ver os dados nelas. Pense na tela chain-4 como sendo uma grande tela. A janela de visão, o pouco que você vê, é um retângulo menor que pode estar em qualquer lugar sobre a tela maior.
+----------------------------+ tela Chain-4
| +--+ |
| | | <- visão |
| +--+ |
| |
+----------------------------+[Mas Denthor, se você pode ver 1/4 da tela de uma vez, o seu diagrama não está um pouco fora da escala?]
<Bem… imagino que sim, mas isso não importa. Só estou tentando mostrar a todos como eles deveriam _pensar_ que é uma tela chain-4.>
[Mas como eles podem entender se você dá pra eles diagramas com defeito?]
<Ah, cale a boca!>
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
O tamanho da tela chain-4
A tela chain-4 pode ser de qualquer tamanho que chegue até 4 telas.
Por exemplo, pode ser 4 telas em linha por uma na vertical, ou uma coluna de quatro telas uma em cima da outra, ou duas telas pro lado e duas pra baixo, e qualquer tamanho entre esses valores.
[Er… Denthor, você já listou as 3 combinações possíveis de layout de chain-4: 1 linha com 4 telas, 4 telas numa coluna, e duas linhas com 2 telas cada. Você está querendo dizer que poderíamos ter algo do tipo 1.5 telas para o lado e 2.5 para baixo? Quero dizer, ei, você está me confundindo.]
<Na verdade, eu só disse isso pra confundir o leitor. Meu plano terrível funcionou! muhaaha…>
No programa de amostra, o tamanho é uma constante. O tamanho *8 é quantos pixels pro lado há na tela chain-4, ou seja:
tamanho = 40 = 320 pixels = 1 tela pro lado, 4 telas para baixo tamanho = 80 = 640 pixels = 2 telas pro lado, 2 telas para baixo etc.
Nós precisamos de saber o tamanho da tela para quase tudo na tela chain-4, por razões óbvias.
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Layout da tela chain-4, e acessando-a
Se você se lembrar de tudo até a parte 1 dessa série, eu expliquei que a memória da tela MCGA é linear. Ou seja, o pixel no topo e à esquerda é o pixel zero, o pixel à direita dele é o um, o próximo é o dois, etc. Com o Chain-4, as coisas são muito diferentes.
[Ei, você não deveria dizer algo como “depois de chegar à direita da tela e voltar para a esquerda (próxima linha) o computador pensa que é o pixel 321, e não linha 2, pixel 1”?]
<Bem, eu apenas _assumi_ que se você já está tão longe na série, você já saberia o layout básico da memória de vídeo!>
[Eta, foi só uma pergunta, não se exalte.]
<O que eu deveria fazer, apenas explicar alegremente o código enquanto você está toda hora enfeitando essas coisas que eu digo? Aliás, todos esses comentários estão diminuindo o entendimento do leitor do código.>
[Denthor, esqueça. Você não tem mais poder aqui. Esse é o MEU domínio agora. Apenas pense em mim como o Borg.]
O Chain-4 pega as 4 telas e as encadeia juntas (daí vem o nome :)). Cada tela tem um valor de plano diferente, e deve ser acessado diferentemente. A razão para isso é que um segmento de memória só tem 64K de tamanho, então não poderíamos encaixar uma tela chain-4 inteira em um segmento.
Todas as telas chain-4 são acessadas de $a000, como no modo MCGA. O que fazemos é, antes de escrevermos na tela, calcular que plano estamos escrevendo, setar esse plano, e então desenhar o pixel. Aqui está como calculamos quão longe plotar o pixel, e em qual pixel ele está:
Ao invés do modelo linar do modo MCGa, isto é:
ÚÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄ¿
³00³01³02³03³04³05³06³07³08³09³10³11³ …
Cada plano da tela Chain-4 acessar a memória desse jeito:
Plano 0 :
ÚÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄ¿
³00³ ³ ³ ³01³ ³ ³ ³02³ ³ ³ ³ ...
Plano 1 :
ÚÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄ¿
³ ³00³ ³ ³ ³01³ ³ ³ ³02³ ³ ³ ...
Plano 2 :
ÚÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄ¿
³ ³ ³00³ ³ ³ ³01³ ³ ³ ³02³ ³ ...
Plano 3 :
ÚÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄÂÄÄ¿
³ ³ ³ ³00³ ³ ³ ³01³ ³ ³ ³02³ ...
Desse modo, escolhendo o plano certo a escrever, podemos acessar todos os 256k da memória disponível para nós. O plano que escrevemos pode ser facilmente encontrado pelo simples cálculo de x mod 4, e a coordenada x também é encontrada fazendo x div 4. Nós calculamos nosso y multiplicando pelo tamanho de nossa tela Chain-4.
[Você poderia ser um pouco MAIS obscuro? Eu tive que ler o último parágrafo três vezes até entender o que você estava dizendo.]
<Ei, eu já sei essas coisas. Por que eu deveria deixar claro para o leitor?… oh espere um minuto, isso é um tutorial! Meu erro, não vai acontecer de novo.>
NOTA : É possível escrever em todos os quatro planos de uma vez, setando-se os valores corretos de portas.
[Alguma chance de você compartilhar esse conhecimento com o leitor?]
<Não, é um segredo da Asphyxia.>
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Usos do Chain-4
Os usos de Chain-4 são muitos. Você poderia escrever dados em uma tela, então fazer um flip dela (o comando move_to é quase instantâneo). Isso significa que 64k de memória não precisam ser setados para uma tela virtual, você está usando a memória da placa VGA, ao invés!
Scroll é muito mais fácil de codificar em Chain-4.
[Scrollers são para lamers.]
<Eu não quis dizer scroll de texto, seu idiota! Eu quis dizer para outras coisas, como mover uma figura pela tela, etc.>
[Ei, olha como você fala comigo, ou eu coloco bugs no código em pascal e digo que você que fez.]
<Você não faria isso!>
[Eu faria.]
<OK, desculpa.>
<[dando as mãos]>
É possível mudar o modo de vídeo para outras resoluções. Em nossa demo, nossos vetores estavam no modo 320×240 e nossos vetores de pontos estavam em 320×400.
A principal desvantagem de chain-4 que vejo, é o swap de planos, que pode ser lento. Com um pouco de codificação esperta, contudo, isso pode ser feito ao mínimo.
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Os programas de amostra
O primeiro programa é o GFX.PAS. Esse é um utilitário em que coloquei a maioria das nossas rotinas de tutoriais anteriores. Todos os procedimentos e variáveis que você pode ver na seção INTERFACE podem ser usadas em qualquer programa com GFX na clausula USES. Em outras palavras, eu poderia fazer assim:
USES GFX,crt; BEGIN Setupvirtual; cls (vaddr,0); Shutdown; END.
[Já é hora de você colocar essas funções num arquivo externo. Droga, eu fiz isso no tutorial 7. Você sabe quanto código redundante você fez os programadores de Pascal usarem?]
<Bem, pode-se dizer que é uma mania minha, mas eu realmente gosto de copiar e colar.>
[hummmm…]
Esse programa compilaria perfeitamente. O que eu sugiro que você faça é o seguinte: renomeie o arquivo para um nome que combine com você (ex.: o nome do seu grupo), mude a primeira linha da unit para aquele nome, então coloque todas aquelas procedures úteis, etc, na unit. Faça-a crescer. 🙂
O segundo arquivo é o programa de amostra (note o USES GFX,crt; lá em cima, perto do topo”). O programa é fácil de entender e é documentado.
[hahaha…. “documentado”? Eu já vi cartões de visita com mais documentação que seus programas.]
<Ei, sem aqueles programas para converter, você não teria nada _útil_ para fazer!>
[Agora isso foi demais! EU faço um comentário sobre sua documentação e você faz piada de mim, desse jeito. Não podemos ficar de bem?]
<Desculpe Snowman. Às vezes meu humor sai de mim.>
<[dando as mãos]>
O ponto que quero chamar sua atenção é para a constante, BIT. Por causa de eu estar distribuindo esse arquivo em muitos lugares em formato texto, e não em binário, eu não poderia apenas colocar um arquivo .CEL com o programa. Então o que eu fiz foi escrever algum texto de uma cor e então salvar como um .CEL. Então escrevi um programa de 10 linhas que fazia o seguinte: Movia da esquerda para a direita, contava quantos pixels eram de cor “zero”, então salvava o valor byte num array. Quando ele cruzava com uma cor “um”, ele contava por quanto tempo era esse valor e salvava num array, e assim por diante. Quando acabasse, eu convertia o array num arquivo texto em formato CONST. Não é muito experto, mas achei melhor explicar 😉
[Na verdade, isso foi uma boa ideia.]
<Obrigado.>
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Fechando
Há outros documentos e programas de amostra disponíveis sobre Chain-4 e semelhantes: tente XLIB para conseguir uma…
Finalmente! Algumas BBS’s juntaram-se à minha lista de BBS’s! (OK, só duas novas, mas já é um começo ;-)) A vocês todas, BBS’s internacionais! Se você baixa regularmente os tutoriais de um FTP site, dê-me seus nomes!
Eu tenho um carro. O nome do carro é Bob. Há poucos dias atrás, Bob teve um acidente, e agora tem um pequeno defeito na frente. Conhecendo o seguro, não vou conseguir muita coisa provavelmente, e provavelmente nada (o outro cara não tinha seguro, e eu só tenho 18 anos 🙁 ). Eu provavelmente vou ter que arrumar um trabalho para pagar o conserto. O ponto que dessa enrolação toda é: eu estou chateado, então, se você acha que vou deixar uma quote, pode esquecer.
Ah, bem. A vida continua!
[O nome do seu carro é Bob? Você dá nome pra sua prataria também?]
<Ei, um carro tem sentimentos como qualquer um. Não caçoe do Bob, ele é muito sensível.>
[Não vai acontecer de novo.]
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
[Esse é Snowman…]
<…e esse é Denthor…>
[<…e NÓS, ESTAMOS, FORA DAQUI! >]
- Krull