CODINGANTIBUG ★ STRUCTURE DE LA MÉMOIRE ÉCRAN DE L'AMSTRAD CPC PAR ANTIBUG ★

Structure de la mémoire écran de l'Amstrad CPC par ANTIBUGCoding Antibug

Rappel sur les modes graphiques supportés par le CPC
Mode 0 160x200 16 couleurs - 4 bits pas pixel, 2 pixels par octet
Mode 1 320x200 4 couleurs - 2 bits par pixel, 4 pixels par octet
Mode 2 640x200 2 couleurs - 1 bit par pixel, 8 pixels par octet
Mode 3 Non traité

1 - Structure de la mémoire
 
La taille de la mémoire graphique, rappelons-le, fait 16 ko. Chaque ligne est entrelacée avec les autres et la largeur d'une ligne fait 80 caractères (octets). 

 
Débuts des adresses de chaque série de lignes

2 - Calcul de l'adresse de base d'un pixel
 
    Comme vous avez pu le constater, pour passer de la ligne 0 à la ligne 1 on ajoute &800 à l'adresse de base et pour passer de la ligne 0 à la ligne 8 on ajoute &50. Les lignes sont regroupées par série de 8 lignes consécutives. A chaque nouvelle série de lignes on ajoute &50 à l'adresse vidéo, de base (&C000 dans notre exemple). Pourquoi &50 ? Tout simplement parce que la largeur de chaque ligne fait 80 octets (&50). La notion de « série de lignes » vient du fait que la mémoire vidéo est organisée ainsi.
 
2.1 Adresse de base d'une ligne vidéo
 
Pour retrouver l'adresse de base d'une ligne ce n'est pas compliqué. Par exemple nous voulons retrouver l'adresse de la ligne 5 : 

[Adresse de base de la ligne] = &C000 + (&800 * 5)

Dans le cas d'une ligne d'une série différente, il faudra prendre en compte le décalage de &50 dû au fait d'un changement de série ; pour cela ce n'est pas très compliqué, on sait que chaque série fait 8 lignes, de 0 à 7 pour la première série, de 8 à 15 pour la seconde, etc. Pour retrouver l'adresse de base de la ligne 12, par exemple, il faut d'abord savoir combien de série de lignes on a passé puis calculer le numéro de la ligne dans la série. Explication par le concret : 

[Numéro de la série de lignes] = (n° de ligne \ 8) [Numéro de la ligne dans la série] = (n° de ligne MOD 8)

Ou, pour la ligne 21 : 

[Numéro de la série] = (21 \ 8) = 2 [Numéro de la ligne dans la série] = (21 MOD 8) = 5

Ce qui nous donne : 

Série 2 5ème ligne

Maintenant pour calculer l'adresse de base de la ligne 21, on calcule son adresse de basse en fonction du n° de sa série puis on ajoute son décalage par rapport à l'adresse de la série, démonstration : 

[Adresse de base de la série] = [Adresse vidéo] + (n° de la série * &50) [Adresse de base de la ligne] = [Adresse de base de la série] + (&800 * n° de la ligne)

Ce qui donne : 

[Adresse de base de la série] = &C000 + (2 * &50) = &C0A0 [Adresse de base de la ligne] = [Adresse de la série] + (&800 * 5) = &C0A0 + &2000 = &E0A0
    Et voilou ! Ce n'est pas compliqué, vous savez maintenant comment trouvé l'adresse de base d'une ligne vidéo ! Il nous reste plus qu'à trouver l'adresse d'un point au coordonnées (X, Y) en fonction du mode graphique, et ce n'est pas plus compliqué …

2.2 Adresse d'un point aux coordonnées (X, Y)
 
    Pour retrouver l'adresse d'un point au coordonnées (X, Y) il suffit de prendre l'adresse de base de sa ligne vidéo Y et d'y ajouter son décalage X. 

Attention ! Le décalage en fonction de X dépend du mode graphique. 

        - En mode 0 le décalage en fonction de X est égal à (X \ 2) car 2 pixels par octet.
        - En mode 1 le décalage en fonction de X est égal à (X \ 4) car 4 pixels par octet.
        - En mode 2 le décalage en fonction de X est égal à (X \ 8) car 8 pixels par octet.

Exemple pour le point aux coordonnées (8, 21) en Mode 0 (16 couleurs):

[Adresse de base du point] = [Adresse de base de la ligne 21] + [Valeur de X \ 2] = &E0A0 + (8 \ 2) = &E0A4
Comme vous l'avez remarqué l'adresse de base de la ligne 21 est celle de l'exemple précédent (2.1), je n'ai pas recalculé l'adresse d'une autre ligne pour ne pas vous embrouiller. 

3 - Entrelacement des pixels
 
3.1 Entrelacement des pixels en Mode 0
 
    On a vu qu'avec le mode graphique 0 (16 couleurs) on pouvait coder 2 pixels dans un octet car chaque pixel a une longueur de 4 bits et bien-sûr un octet 8 bits. On pourrait donc se dire dans les bits 7,6,5,4 je vais coder le premier pixel et dans les bits 3,2,1,0 le second … Mais c'est là qui y'a un blême ! Les deux pixels sont entrelacés !

    Et oui ! La couleur du premier pixel est codée sur les bits 7,5,3,1 et celle du second pixel sur les bits 6,4,2,0. Voilà qui ne va pas arranger nos affaires ! Par de panique il y a toujours une solution … 

3.2 Entrelacement des pixels en Mode 1
 
    En ce qui concerne le mode 1, l'entrelacement de pixel est similaire à celui du Mode 0 à ceci près que chaque pixel n'est plus codé sur 4 bits mais 2 ; nous n'avons que 2 couleurs à coder.

3.3 Entrelacement des pixels en Mode 2
 

    Pour le Mode 2 ce n'est pas compliqué, c'est le plus simple, chaque bit d'un octet correspond à 1 pixel, donc 8 pixels par octet. Et oui, codage de 2 couleurs seulement …


Le premier pixel se trouve au bit 7, etc. Rien à ajouter. 

4 – Affichage d'un pixel
 
4.1 Affichage d'un pixel en Mode 0
 
    On a vu dans les paragraphes précédents comment calculer l'adresse vidéo, de base d'un point. On a vu aussi comment étaient codés 2 pixels dans un octet. Maintenant nous allons voir comment afficher un pixel. 

    Avant d'afficher quoi que ce soit il faut d'abord savoir ce que l'on veut faire … On veut afficher un point à l'écran avec une couleur bien spécifique. Le problème c'est que l'on ne peut pas directement mettre la valeur de la couleur du point dans l'octet associé à ce point ; vu que deux pixels sont codés dans un octet et que ces pixels sont entrelacés, si l'on modifie directement l'octet en question l'information sur la couleur des deux pixels existants sera modifiée et il va s'afficher n'importe quoi. 

Pour afficher correctement un pixel à l'écran réfléchissons aux différents problèmes que l'on va rencontrer : 

    1 - Savoir quels sont les bits du pixel à modifier en fonction de sa coordonnée.
    2 - Lors de l'affichage d'un pixel, ne pas modifier la couleur du pixel voisin.
    3 - Encoder le numéro de la couleur du pixel à afficher pour contourner le 
         problème de l'entrelacement. 


1 – En effet, sachant que sont codés deux pixels dans un octet il faut savoir quel pixel correspond à telle série de bits ? Pour cela il suffit de regarder si sa coordonnées X un pair ou impair. Imaginons que X soit égal à 12, en binaire on a %1100, le bit 0 étant égal à zéro il s'agit d'un nombre pair. Réciproquement pour codé la valeur 13, en binaire on a %1101 le bit 0 égal 1 donc le chiffre à codé est impair. Exemple dans notre cas : 

Si X = 0 : 

    Bit 0 de X = 0 (pair), correspondra donc au premier pixel à afficher 

Si X = 1 : 

    Bit 0 de X = 1 (impair), correspondra donc au second pixel à afficher 


2 - Pour ne pas modifier la couleur du pixel voisin on va utiliser un masque binaire ; ce masque va nous permettre préserver sa couleur et supprimer celle du pixel à modifier. Un second masque sera appliqué pour modifier la couleur du nouveau pixel. 

Rappel sur le masque AND (en binaire): 

%1100 AND %1010 = %1000
    Et oui le résultat d'un ET logique entre une valeur source1 et une valeur source2, ne préserve que les bits égaux à 1: 

A B AND
1 0 0
0 1 0
1 1 1

    Vous verrez rapidement l'intérêt d'une telle opération ... 


3 – Pour contourner le problème de l'entrelacement des pixels, nous allons passer par une table de correspondance entre la couleur à afficher et la valeur réelle à stocker en mémoire. Sachant que les couleurs de nos deux pixels sont entrelacées, passons d'abord en revu les différentes valeurs possibles pour les couleurs du 1er pixel. 

Masques liés au 1er pixel
couleur valeur après entrelacement
0 %00000000 0
1 %00000010 2
2 %00001000 8
3 %00001010 10
4 %00100000 32
5 %00100010 34
6 %00101000 40
7 %00101010 42
8 %10000000 128
9 %10000010 130
10 %10001000 136
11 %10001010 138
12 %10100000 160
13 %10100010 162
14 %10101000 168
15 %10101010 170

Cette table va nous servir pour trouver la correspondance de chaque couleur à afficher. En effet, lorsque l'on voudra afficher un pixel avec la couleur15, on prendra la valeur associée 170 (%10101010) ; cette dernière étant près entrelacée il nous restera plus qu'à l'afficher. 

Avec toutes ces informations regardons maintenant toutes les étapes pour afficher un pixel : 

    1 – Calculer l'adresse du pixel en fonction des coordonnées (X, Y).
    2 – Regarder quel pixel doit être allumé (pair ou impaire).
    3 – Récupérer la valeur de l'octet se trouvant à l'adresse du pixel.
    4 – Appliquer les filtres logiques.
    5 – Stockage de la nouvelle valeur de l'octet à l'adresse du pixel.


Exemple 1 – Codage d'un pixel pair: 

    Affichage d'un pixel aux coordonnées (X = 0, Y = 0) avec la couleur 6. Les couleurs initiales des deux pixels de l'octet aux coordonnées (X, Y) avant modification sont 1 pour le premier pixel et 15 pour le second ; ce qui donnes en binaire, une fois les valeurs entrelacées : %01010111 (87) 

1 – L'adresse de l'octet du pixel aux coordonnées (X = 0, Y = 0) est égal à &C000.
2 – Le pixel est un pixel pair car X = 0 (bit 0 de X = 0)
3 – La couleur initiale de l'octet se trouvant à l'adresse &C000 est égal à %01010111
4 – Nous allons maintenant éteindre le premier pixel en appliquant un filtre logique :

[Couleur calculée] = [Couleur initiale] AND [Masque logique] = 87 AND 85 = %01010111 AND %01010101 = %01010101 = 85
    Ici nous n'avons préservé que les bits de la couleur du second pixel 

Il nous reste plus qu'à coder la couleur du pixel à afficher (le premier pixel). Pour cela, nous allons appliquer un OU logique entre la valeur calculée de l'octet (celle précédemment calculée) et la valeur entrelacée, associée la couleur du premier pixel. 

[Nouvelle valeur de l'octet] = [Valeur modifiée] OR [Table correspondance(6)] = 85 OR 40 = %01010101 OR %00101000 = %01111101 = 125

Infos : Cet exemple ne permet d'encoder qu'un pixel pair. Pour les pixels impairs, les valeurs de la table de correspondance doivent être divisées par 2 (ou décalage d'1 bit vers la droite), un exemple sera traité après. 

5 - Pour terminer, nous allons stocker la nouvelle valeur de l'octet à l'adresse du pixel … 

&C000 = 125

Exemple 2 – Codage d'un pixel impair: 

    Affichage d'un pixel aux coordonnées (X = 1 Y = 0) avec la couleur 6. Comme dans l'exemple précédent, les couleurs initiales des deux pixels de l'octet aux coordonnées (X, Y) avant modification sont 1 pour le premier pixel et 15 pour le second ; ce qui donnes en binaire, une fois les valeurs entrelacées : %01010111 (87) 

1 – L'adresse de l'octet du pixel aux coordonnées (X = 1, Y = 0) est égal à &C000.
2 – Le pixel est un pixel impair car X = 1 (bit 0 de X = 1)
3 – La couleur initiale de l'octet se trouvant à l'adresse &C000 est égal à %01010111
4 – Nous allons maintenant éteindre le second pixel en appliquant un filtre logique :


[Couleur calculée] = [Couleur initiale] AND [Masque logique] = 87 AND 170 = %01010111 AND %10101010 = %00000010 = 2
    Après l'application du masque logique, nous n'avons préservé que les bits de la couleur du premier pixel. 

    Il nous reste plus qu'à coder la couleur du pixel à afficher (le second pixel). Pour cela, nous allons appliquer un OU logique entre la valeur calculée de l'octet (celle précédemment calculée) et la valeur entrelacée, associée la couleur du second pixel. 

[Nouvelle valeur de l'octet] = [Valeur modifiée] OR [Table correspondance(6) \ 2] = 2 OR (40 \ 2) = %00000010 OR %00010100 = %00010110 = 22
5 - Pour terminer, nous allons stocker la nouvelle valeur de l'octet à l'adresse du pixel … 

&C000 = 22

    Et voilà celui-ci est allumé ! Enjoy !!! 


4.2 Affichage d'un pixel en Mode 1
 
    En mode graphique 1, chaque pixel est codé sur 2 bits, représentant ainsi une combinaison de 4 couleurs (de 0 à 3). Chaque octet contient 4 pixels, nous allons voir comment codé un pixel: 

    Nous avons vu précédemment comment calculé l'adresse de base d'une ligne et d'un pixel à partir d'un système de coordonnées (X, Y). Nous allons étudier maintenant comment traiter un pixel en particulier. Nous avons vu que pour afficher un pixel en mode 16 couleurs (Mode 0) les bits de chacune des couleurs devaient être entrelacés et qu'il nous fallait une table de correspondance (couleurs d'origine => valeurs après entrelacement). Pour l'affichage de pixels en Mode 1 c'est identique, nous allons devoir utiliser une table de correspondance; celle-ci sera plus petite car nous n'avons que 4 couleurs à coder et pas 16. 

    Les valeurs pré-calculées de la table vont correspondre à celles associées au premier pixel (pixel utilisant les bits 7 et 3 de l'octet), elles serviront de masques logiques pour afficher les couleurs. Pour calculer les valeurs des autres pixels, nous prendrons celles de la table et nous effectuerons un décalage binaire de celles-ci vers le bas (la droite). 

Contenu de la table de correspondance: 

Masques liés au 1er pixel
couleur valeur après entrelacement
0 %00000000 0
1 %00001000 8
2 %10000000 128
3 %00001000 136

    Comment savoir quel pixel traité dans l'octet ? Ce n'est pas compliqué ! Sachant que l'on a 4 pixels par octet, il suffit de regarder les 3 derniers bits de X pour savoir quel est le numéro du pixel concerné (sachant que leur numérotation va de 0 à 3). 

Exemple: 

    Prenons un point aux coordonnées X = 13, Y = 0 et de couleur 2. Pour trouver l'octet concerné par l'affichage du pixel nous divisons X \ 4. 

[Octet concerné] = X \ 4 = 3 (4ème octet car leur numérotation commence à 0)

    Maintenant pour trouver quel est le pixel à afficher (dans l'octet), nous regardons les 3 derniers bits de la valeur de X. 

[Pixel concerné, dans l'octet] = X AND 3 = 1 (2ème pixel, la numérotation commence à 0)

A ce stade, nous connaissons l'octet concerné par l'affichage du pixel et nous connaissons le numéro du pixel à afficher: octet 3, pixel 1. Calculons maintenant la valeur du masque logique qui va nous servir à modifier la couleur du pixel; nous allons utiliser la table de correspondance. 

    Nous voulons afficher le pixel avec la couleur 2. Dans la table la valeur entrelacée liée à la couleur 2 est 128 (%10000000 en binaire). Nous savons que cette valeur est associée au 1er pixel (le pixel P0), nous allons donc recalculer cette valeur pour le second pixel; pour cela il suffit de décaler vers le bas cette valeur en fonction du numéro du pixel précédemment calculé : 

[Nouvelle valeur] = [Table correspondance(2)] \ (2 ^ [N° du pixel concerné, dans l'octet]) = 128 \ (2 ^ (13 AND 3)) = 128 \ (2 ^ 1) = 64 (%01000000 en binaire)     Ici pour effectuer une rotation des bits vers le bas nous utilisons une division entière par 2. L'opération (2 ^ n) a pour effet d'élevé 2 à la puissance n pour savoir combien de rotation nous devons effectuer en fonction du numéro du pixel; bien-sûr, en assembleur il faudrait remplacer toute l'opération par une simple rotation de bits. 

Bilan : Nous avons le numéro de l'octet, le numéro du pixel et la valeur entrelacée de sa couleur; nous n'avons plus qu'à modifier sa couleur. Pour cela nous allons de nouveau utiliser un masque logique, masque qui va nous permettre de préserver les bits des pixels aux alentours, d'effacer l'ancienne couleur de notre pixel, puis d'appliquer sa nouvelle couleur. Ce masque correspond à la valeur 136 (%10001000) décalée vers le bas (la droite) d'autant de fois que le numéro du pixel : 

[Valeur du masque] = NOT (136 \ (2 ^ (X AND 3))) = NOT (%10001000 \ (2 ^ 1)) = NOT (%10001000 \ 2) = NOT (%01000100) = %01110111 Préservation des autres pixels : 

[Nouvelle valeur de l'octet] = [Ancienne valeur de l'octet] AND [Valeur du masque]

    L'opération logique ET permet de ne garder que les bits des valeurs source1 et source2 à 1. (voir plus haut) 

Nouvelle couleur appliquée : 

[Nouvelle valeur de l'octet] = [Nouvelle valeur de l'octet] OR [Nouvelle valeur entrelacée de la couleur]

    Ici le OU logique a pour but de n'allumer que les bits de la couleur entrelacée à 1. 
    Donc d'appliquer la nouvelle couleur. 

Pour terminer, stockons la nouvelle valeur de l'octet et allumons le pixel : 

&C003 = [Nouvelle valeur de l'octet]


4.3 Affichage d'un pixel en Mode 2
 
    Pour l'affichage d'un pixel en Mode 2, l'opération est exactement la même qu'en Mode 1 à ceci près qu'en Mode 2 on code 8 pixels par octet et que chaque pixel est codé sur 2 bits et ne peut prendre que 2 couleurs (0 ou 1). 


    Pour calculer le numéro de l'octet nous allons effectuer une division modulo 8 à partir de la valeur de X : 

[Numéro de l'octet concerné] = X MOD 8

    Sachant que l'on peut coder 8 pixels par octet et qu'un pixel ne peut prendre que la valeur 0 ou 1, le calcul du numéro du pixel peut être définit comme suit : 

[Numéro du pixel concerné]= X AND 7

Exemple : 


    Nous voulons allumer un pixel se trouvant aux coordonnées (X = 1, Y = 0) et de couleur 1. Il va nous falloir calculer 2 masques logiques, l'un pour préserver les pixels aux alentours tout en effaçant la valeur de notre ancien pixel, l'autre pour pouvoir allumer la nouvelle valeur de notre pixel. 


[Numéro de l'octet concerné] = X MOD 8 = 0 [Numéro du pixel concerné] = X AND 7 = 1

Ce qui implique : 

    Octet 0
    Pixel 1 (bit 6) 

    Dans cet exemple nous pouvons voir que le pixel à allumer se trouve au 6ème bit, il va donc falloir préserver les bits des pixels restant pour ne pas affecter leur couleur. Pour cela nous allons calculer un premier masque logique. Nous partons du 7ème bit et nous allons décaler ce bit vers le bas (la droite) en fonction du numéro du pixel précédemment calculé, puis nous prendrons l'inverse de la valeur issue du calcul: 

[Masque logique 1] = NOT (128 \ (2 ^ (X AND 7))) = NOT (%10000000 \ (2 ^ (1 AND 7))) = NOT %01000000 = %10111111

    Maintenant nous allons calculer le second masque qui va nous permettre de modifier la valeur de notre nouveau pixel. Comme pour les exemples précédents, nous allons utiliser une table de correspondances pour trouver la valeur entrelacée associée à la couleur à afficher. En Mode 2 la table de correspondances ne fait que 2 lignes car nous n'avons que 2 couleurs à coder (sur 1 bit, 0 ou 1). Vous me direz … une table pour coder 2 couleurs ? Il est vrai que celle-ci est facultative et qu'il y a d'autres moyens d'allumer un pixel ; nous allons quand même garder cet exemple. 

Masques liés au 1er pixel
couleur valeur après entrelacement
0 %00000000 0
1 %10000000 128

[Masque logique 2] = [Table de correspondances(1)] \ (2 ^ (X AND 7)) = %10000000 \ (2 ^ (1 AND 7)) = %01000000

Il nous reste plus qu'à affecter la nouvelle valeur de notre pixel puis afficher le résultat : 

[Nouvelle valeur de l'octet] = ([Ancienne valeur de l'octet] AND [Masque 1]) OR [Masque 1] &C000 = [Nouvelle valeur de l'octet concerné]
Et voilà ... 

5 – Partie code
 
5.1 Affichage d'un pixel en Mode 0
  10 '******************************************
20 ' Affichage d'un pixel en mode 0
30 '
40 ' date: 30/03/2007
50 ' auteur: vincentbouffigny.cpc@free.fr
60 ' releases:
70 '******************************************
80 MODE 0
90 INK 0,0
100 video = &C000
110 offset = 0
120 x = 0 : y = 0 : c = 0
130 masque = 0
140 DIM assoc(15)
150 assoc(0) = 0 '%00000000
160 assoc(1) = 2 '%00000010
170 assoc(2) = 8 '%00001000
200 assoc(3) = 10 '%00001010
210 assoc(4) = 32 '%00100000
220 assoc(5) = 34 '%00100010
230 assoc(6) = 40 '%00101000
240 assoc(7) = 42 '%00101010
250 assoc(8) = 128 '%10000000
260 assoc(9) = 130 '%10000010
270 assoc(10) = 136 '%10001000
280 assoc(11) = 138 '%10001010
290 assoc(12) = 160 '%10100000
300 assoc(13) = 162 '%10100010
310 assoc(14) = 168 '%10101000
320 assoc(15) = 170 '%10101010
310 X = 0320 y = 0
330 c = 13 ' c de 0 à 15
340 GOSUB 410
350 x = 1
360 y = 1
370 c = 10 ' c de 0 à 15
380 GOSUB 410
390 GOTO 530
400 ' Calcul de l'adresse de base du point à partir des coordonnees (x, y)
410 offset = &50 * (y \ 8)
420 offset = offset + (&800 * (y MOD 8))
430 offset = offset + (x \ 2)
440 HL = video + offset
450 c = c AND 15 ' couleur de 0 à 15
460 c = assoc(c) \ (2 ^ (x AND 1)) ' a remplacé par une rotation binaire
470 masque = 85 * (2 ^ (x AND 1)) ' 85 <=> %01010101
480 v = PEEK(HL)
490 v = v AND masque
500 v = v OR c520 POKE HL, v
520 RETURN
530 s$ = INKEY$
540 IF s$ = "" THEN GOTO 530
550 INK 0,1
560 MODE 2
570 LIST

5.2 Affichage d'un pixel en Mode 1
  10 '******************************************
20 ' Affichage d'un pixel en mode 1
30 '
40 ' date: 30/03/2007
50 ' auteur: vincentbouffigny.cpc@free.fr
60 ' releases: 70 '******************************************
80 MODE 1
90 INK 0,0
100 video = &C000
110 offset = 0
120 x = 0 : y = 0 : c = 0
130 masque = 0
140 DIM assoc(4)
150 assoc(0) = 0 '%00000000
160 assoc(1) = 8 '%00001000
170 assoc(2) = 128 '%10000000
180 assoc(3) = 136 '%10001000
190 x = 1
200 y = 0
210 c = 3 ' c de 0 à 3
220 GOSUB 290
230 x = 5
240 y = 1
250 c = 1 ' c de 0 à 3
260 GOSUB 290
270 GOTO 410
280 ' Calcul de l'adresse de base a partir des coordonnees x, y
290 offset = &50 * (y \ 8)
300 offset = offset + (&800 * (y MOD 8))
310 offset = offset + (x \ 4)
320 HL = video + offset
330 c = c AND 3 ' couleur de 0 à 3
340 c = assoc(c) \ (2 ^(x AND 3)) ' a remplacé par une rotation binaire
350 masque = NOT (136 \ (2 ^(x AND 3))) ' 136 <=> %10001000
360 v = PEKK(HL)370 v = v AND masque
380 v = v OR c
390 POKE HL, v
400 RETURN
410 s$ = INKEY$
420 IF s$ = "" THEN GOTO 410
430 INK 0,1
440 MODE 2
450 LIST

5.3 Affichage d'un pixel en Mode 2
  10 '******************************************
20 ' Affichage d'un pixel en mode 2
30 '40 ' date: 02/04/2007
50 ' auteur: vincentbouffigny.cpc@free.fr
60 ' releases:
70 '******************************************
80 MODE 2
90 INK 0,0
100 video = &C000
110 offset = 0
120 x = 0 : y = 0 : c = 0
130 masque = 0
140 DIM assoc(4)
150 assoc(0) = 0 '%00000000
160 assoc(1) = 128 '%10000000
170 x = 639180 y = 199
190 c = 1 ' c 0 ou 1
200 GOSUB 270
210 x = 0
220 y = 10
230 c = 1 ' c 0 ou 1
240 GOSUB 270
250 GOTO 380
260 ' Calcul de l'adresse de base a partir des coordonnees x, y
270 offset = &50 * (y \ 8)
280 offset = offset + (&800 * (y MOD 8))
290 offset = offset + (x \ 8)
300 HL = video + offset
310 c = c AND 1 ' Couleur 0 ou 1
320 c = assoc(c) \ (2 ^ (x AND 7)) ' a remplacé par une rotation binaire
330 masque = NOT (128 \ (2 ^ (x AND 7)))
340 v = PEEK(HL)
350 v = v AND masque
360 v = v OR c
370 POKE HL, v
380 RETURN
390 s$ = INKEY$
400 IF s$ = "" THEN GOTO 390
410 INK 0,1
420 MODE 2
430 LIST

 
contact : vincentbouffigny.cpc@free.fr 
web : http://ovi.org.free.fr - http://projets.infos.free.fr

 

★ LICENCE: ???
★ ANNÉE: 2007]
★ AUTEUR: ANTIBUG

CPCrulez[Content Management System] v8.75-desktop/c
Page créée en 062 millisecondes et consultée 1677 fois

L'Amstrad CPC est une machine 8 bits à base d'un Z80 à 4MHz. Le premier de la gamme fut le CPC 464 en 1984, équipé d'un lecteur de cassettes intégré il se plaçait en concurrent  du Commodore C64 beaucoup plus compliqué à utiliser et plus cher. Ce fut un réel succès et sorti cette même années le CPC 664 équipé d'un lecteur de disquettes trois pouces intégré. Sa vie fut de courte durée puisqu'en 1985 il fut remplacé par le CPC 6128 qui était plus compact, plus soigné et surtout qui avait 128Ko de RAM au lieu de 64Ko.