Seawar 0.64 DIY
Seawar 0.64


Here is a "Do It yourself" release of Seawar. If you want to play that game, you'll have to create it first!
What you have to do: copy the asm code between the two h-rules in a file 'sw.asm', change what you want into the 'DIY' section and make the program (use for exemple TIGCC or FARGO).

What you can change:

    *the calculator: "ti92" 0=ti-92+, 1=ti92
    *the color of the pointer "curseur" 1=dark, 0=bright
    *the language: "langue" 0=French, 1=English
    *the length "bat1-bat5" of the five ships, 2,3,4 or 5

Don't try any other value or it should crash!
Don't change anything out of the "DIY"part without my agreement.
Enjoy!


 ;******************************** Seawar 92 *********************************
 ;;
 ;; Seawar pour		TI-92 avec Fargo II, TI-92+ avec kernel
 ;; Version		0.64
 ;; Programmé sur	TI-92 v2.1
 ;;
 ;; Programmé par	Christophe Molon-Noblot
 ;; Mail:		ximoon@voila.fr
 ;; URL:		http:\\ximoon.multimania.com
 ;; ICQ:		97005430
 ;;
 ;****************************************************************************

 ;******************************* commentaires *******************************
 ;;	
 ;; Ceci est mon premier (gros) programme en assembleur.
 ;; C'est d'ailleurs une adaptation en asm de mon premier jeu en
 ;; basic pour ti-92.
 ;; J'ai mis tout plein de commentaires pour les curieux.
 ;;
 ;; Vu que je découvrais l'assembleur en programmant, le code n'est pas
 ;; toujours d'une grande finesse... Mais du moment que ça marhe ;o)
 ;; 
 ;; Merci de me reporter tout bug (je serais surpris que personne ne trouve
 ;; de vrai bug (abandon du tir sur un bateau touché par exemple) dans la 
 ;; phase de tir de l'ordinateur...) et de ne pas faire de modification
 ;; sans me prévenir.
 ;; 
 ;; Ce jeu existe également en basic, il est disponible sur www.ticalc.org
 ;;
 ;; Tout joueur doit être conscient du risque qu'il prend, je ne peux pas être
 ;; considéré comme responsable des dommages que pourrait provoquer ce programme.
 ;; J'éspère quand même que ce jeu ne fera pas crasher trop de machines...
 ;;
 ;****************************************************************************
 ;********************************** le jeu **********************************
 ;;
 ;; Ce jeu nécessite une ti-92 avec Fargo II (V.2.7.1) de David Ellsworth,
 ;; il utilise alors graphlib et gray4lib. Pour TI-92+, il faut un kernel
 ;; et simplement graphlib.
 ;;
 ;; Seawar est une bataille navale qui se joue sur une grille de 10*10
 ;; cases. Chaque joueur doit placer un porte-avions (5 cases), une
 ;; frégate (4 cases), deux destroyers (3 cases) et un sous-marin
 ;; (2 cases). Les bateaux ne peuvent pas se toucher, même en diagonale.
 ;; Pour placer un bateau, séléctionner la case, appuyer sur [enter]
 ;; puis choisir le sens avec les flèches. Le gagnant est celui qui
 ;; coule le premier tous les bateaux de son adversaire. Les deux
 ;; joueurs jouent le même nombre de coups, il peut donc y avoir
 ;; égalité.
 ;; Deux modes sont disponible: 1 joueur contre l'ordinateur ou
 ;; 2 joueurs l'un contre l'autre.
 ;; Il est possible de quitter en appuyant sur [esc] à tout moment,
 ;; la partie est alors définitivement quittée.
 ;; [lock] équivaut à [enter], [F1] et [F2] permattent de régler le contraste.
 ;;
 ;; Bon jeu!
 ;;
 ;****************************************************************************

 ;******************************* historique *********************************
 ;;
 ;; Versions basic:
 ;;
 ;; 1997-1999	Versions 1.x
 ;; Pour ti-82 (!!!)
 ;; Mode deux joueur terminé, mode 1 joueur non aboutit...  un jour peut-être
 ;;
 ;; 1999-2000	Versions 2.x
 ;; Pour ti-92/ti-92+
 ;; Modes 1 et 2 joueurs complets
 ;; Début d'adaptation pour ti-89
 ;;
 ;; Versions assembleur
 ;;
 ;; Début:	13/11/2000
 ;; Début du programme ET de mon apprentissage de l'asm
 ;;
 ;; 09/01/2001	V. 0.1		4??? octets
 ;; Traçage de la grille
 ;; Menu principal
 ;; Placement des bateaux pour le joueur 1 et l'ordinateur
 ;; Traçage des bateaux
 ;;
 ;; 14/01/2001	V. 0.2		4864 octets
 ;; Vérification du placement des bateaux
 ;;
 ;; 30/01/2001	V. 0.3		9??? octets
 ;; Création de sprites pour les navires
 ;; Réécriture du code d'affichage des bateaux
 ;;
 ;; 05/02/2001	V. 0.4		8??? octets
 ;; Partie placement 1 et 2 joueurs terminée
 ;; Suppression des masques pour les sprites
 ;;
 ;; 10/02/2001	V. 0.5		7586 octets
 ;; Tir joueurs 1 et 2 terminé
 ;; Fenêtre de dialogue
 ;; Début de l'optimisation
 ;; Mode deux joueurs terminé
 ;;
 ;; 05/03/2001	V. 0.6.b	8742 octets
 ;; Tir de l'ordinateur terminé
 ;; Première bêta
 ;;
 ;; 04/04/2001	V. 0.62.b	8471 octets
 ;; Modulation du contraste par F1-F2
 ;; Activation de Lock=Enter
 ;; On éteind la calculatrice
 ;; Optimisation toujours...
 ;;
 ;; 07/06/2001	V. 0.63.b	7574/7997 (92/92+) octets
 ;; Version 92+
 ;; Optimisation, réorganisation...
 ;;
 ;; 06/07/2001	V. 0.64	7720/7869 octets
 ;; Sauvegarde de la case sélectionnée
 ;; Adoption de la routine de scannage du clavier d'ExtendeD
 ;; (la mienne marchait sous vti, mais buggait on-calc depuis 
 ;; la version 0.62.b...)
 ;; Déplacement du curseur en diagonale
 ;; !Public released!
 ;;
 ;; Les dernières mises à jours sont toujours disponibles sur mon site: http:\\ximoon.multimania.com
 ;; J'ai finalement décidé d'ouvrir la source :o)
 ;;
 ;; A faire (peut-être...):
 ;;
 ;; Jeu par câble? => franchement là, je ne suis pas chaud (j'ai déjà essayé et abandonné...)
 ;; Version ti-89 (plus tard... ça marche, à l'écran près...)
 ;; Option: choisir ses bateaux?
 ;; Améliorer "l'intelligence" de l'ordinateur (pour ça, je sais
 ;; quoi faire, mais pas encore comment le faire... ça viendra)
 ;; Sauvegarde de la partie en cours?
 ;; Autre chose? Mail!
 ;;
 ;; Toutes les idées, remarques et autres critiques (constructives)
 ;; sont les bienvenues: ximoon@voila.fr
 ;;
 ;****************************************************************************

 ;**************************** remerciements  à... ***************************
 ;;
 ;; David Ellsworth... mais pourquoi donc?
 ;; La Doors Team pour graphlib
 ;; Toute la communauté de www.ti-fr.org: j'ai beaucoup appris (et
 ;; je me suis bien marré) sur le forum :o)
 ;; Tous ceux qui jouent à ce jeu...
 ;;
 ;; Un grand merci à ExtendeD pour m'avoir initié à l'asm, pour ses tests,
 ;; pour ses routines, pour sa patiente, pour me supporter, enfin bref
 ;; pour son aide en général.
 ;;
 ;****************************************************************************

 ;*********************************** DIY ************************************
ti92			equ	1			; 92+=0, 92=1
curseur			equ	1			; curseur de sélection de case: 1=foncé, 0=clair
langue			equ	1			; 0=français, 1=English
bat1			equ	2			; longueur des bateaux
bat2			equ	3			; par défaut: 2,3,3,4,5
bat3			equ	3
bat4			equ	4
bat5			equ	5
 ;****************************************************************************

	ifeq	ti92					; compile pour 92+ et 89 si ti92=0
gray4lib::plane1	equ	graphlib::plane0	; pour ti-89 et 92+
gray4lib::plane0	equ	graphlib::plane1	;
gray4lib::on		equ	graphlib::gray4	;
gray4lib::off		equ	graphlib::gray2	;
tios::FontSetSys	equ	_ROM_CALL_18F	;
tios::DrawStrXY		equ	_ROM_CALL_1A9	;
	include	"DoorsOs.h"	;
	xdef	_ti92plus	;
	endif
	ifeq	ti92-1	; compile pour 92 si ti92=1
	include	"gray4lib.h"	; pour ti-92
	include	"tios.h"	;
	endif
	include	"graphlib.h"	; pour toutes les calcs
	xdef	_main	; adresse du début du code
	xdef	_comment	; adresse du commentaire
 ;********************************** macros **********************************
scan	MACRO 
; input: 	ligne,col
; 	a2 pointe sur KbdMat
	btst.b	#\2,\1(a2)
	ENDM
 ;***************************** sous programmes ******************************
 ;****************************** efface l'écran ******************************
 clrscr:
	lea	graphlib::clr_scr,a0	; efface l'écran pointé par a1
	move.l	gray4lib::plane0,a1 	; séléctionne l'écran gris clair
	jsr	(a0)
	move.l	gray4lib::plane1,a1 	; séléctionne l'écran gris foncé
	jsr	(a0)
	rts
 ;************************** pour ralentir un brin ***************************
 wait:
	move.w	#$2000,d6
 bcl:
	dbra	d6,bcl
	rts
 ;******************* séléctionne une case sur la grille *********************
 selec:
 ; input	a5.w = numéro de grille (0 ou 1)
 ; output	a3.w = x
 ; 	a2.w = y	
	ifeq	curseur
	move.l	gray4lib::plane0,a1 	; séléctionne l'écran gris clair
	endif
	ifne	curseur
	move.l	gray4lib::plane1,a1 	; il paraît que c'est mieux en foncé alors...
	endif
	clr.l	d0
	clr.l	d1
	lea	u1,a0		; permet de remettre sur la case précédemment choisie
	move.b	joueur,d0
	add	d0,a0
	move.b	(a0),d0
	move.b	2(a0),d1
	move	d0,a3
	move	d1,a2
	lsl.w	#3,d0
	lsl.w	#3,d1
	add	#16,d0
	exg	d0,d5
	moveq	#110,d0
	sub	d1,d0
	exg	d0,d1
	moveq	#6,d2	; largeur
	moveq	#6,d3	; hauteur
	clr.w	d4	; en noir
 boucle:
	bsr	mtrd5
 sgetk:
	move.b	#1,sel
	bsr	getk
	clr.b	sel
	cmp.w	#5,d0
	beq	enterapp2
	tst.w	d0
	beq	sgetk
	bsr	mtrd5
	clr.l	d6
	move.b	vdpl,d6
	ext.w	d6
	add.w	d6,a2
	muls.b	#8,d6
	sub.b	d6,d1
	move.b	hdpl,d6
	ext.w	d6
	add.w	d6,a3
	muls.b	#8,d6
	add.b	d6,d5
 hautapp2:
	cmp.w	#11,a2
	beq	vplus
	bra	basapp2
 vplus:
	moveq	#102,d1
	move.w	#1,a2
 basapp2:
	cmp.w	#0,a2
	beq	vmoins
	bra	droiteapp
 vmoins:
	moveq	#30,d1
	move.w	#10,a2
 droiteapp:
	cmp.w	#11,a3
	beq	hplus
	bra	gaucheapp
 hplus:
	move.w	#1,a3
	moveq	#24,d5
 gaucheapp:
	cmp.w	#0,a3
	beq	hmoins
	bra	boucle
 hmoins:
	move.w	#10,a3
	moveq	#96,d5
	bra	boucle
 enterapp2:
	bsr	mtrd5
	clr.l	d0
	lea	u1,a0	; sauvegarde la case choisie
	move.b	joueur,d0
	add	d0,a0
	move	a3,d0	; u1.l= xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
	move	a2,d1	;         x j2     x j1     y j2     y j1
	move.b	d0,(a0)
	move.b	d1,2(a0)
	rts
 mtrd5:
	move	a5,d0
	mulu.w	#110,d0	; ajoute le décalage entre le grilles
	add.w	d5,d0
	bsr	mtr	; trace le rectangle
	rts
 ;********************************** getkey **********************************
 getk:
	movem.l	a0-a2/d1/d3/d7,-(a7)
	clr.w	vdpl
 ScanKbd:		; keyScan par ExtendeD
	moveq	#9,d0
	lea	KbdMat,a0
	move.w	#%1111111111111110,d3
 SaveRow:
	move.w	d3,$600018
	moveq	#11,d1	; d1=0
 WaitKeys:
	dbra	d1,WaitKeys
	move.b	$60001B,(a0)+
	rol.w	#1,d3
	dbra	d0,SaveRow	
	lea	KbdMat,a2	; dixit: "clair, facile à utiliser, efficace, rapide"
	clr	d0
 gapp:
	scan	0,4
	beq	gaucheapp1
 dapp:
	scan	0,6
	beq	droiteapp1
 happ:
	scan	0,5
	beq	hautapp1
 bapp:
	scan	0,7
	beq	basapp1
 eapp:
	scan	0,3
	beq	enterapp1
	scan	6,4
	beq	f1app
	scan	4,4
	beq	f2app
	scan	6,6
	beq	enterapp1
	scan	9,1
	beq	enterapp1
	scan	8,6
	beq	escapp1
	clr.b	ancd0
	btst.b	#1,$60001A	; la touche [ON] est appuyée ?
	bne	ScanKbd	
	trap	#4	; si oui éteind la calc
	bra	ScanKbd
 f2app:
	moveq	#1,d0	; $9 pour contrastup()
 f1app:
	add.w	#9,d0	; $A pour contrastdown()
	trap	#9	; retourne l'addresse de la romcall dans a0
	jsr	(a0)	; appelle la romcall
	bra	pauserts
 hel:
	scan	0,5
	beq	hautapp1
	scan	0,7
	beq	basapp1
	bra	pauserts
 gaucheapp1:
	moveq	#1,d0
	move.b	#-1,hdpl
	cmp.b	#1,sel
	bne	pauserts
	bra	hel
 droiteapp1:
	moveq	#2,d0
	move.b	#1,hdpl
	cmp.b	#1,sel
	bne	pauserts
	bra	hel
 hautapp1:
	moveq	#3,d0
	move.b	#1,vdpl
	bra	pauserts
 basapp1:
	moveq	#4,d0
	move.b	#-1,vdpl
	bra	pauserts
 escapp1:
	bra	fin2
 enterapp1:
	moveq	#5,d0
 pauserts:
	move.w	#$9000,d7
 pausebcl:
	dbra	d7,pausebcl
	cmp.b	ancd0,d0	
	beq	prts	; pour aller plus lentement au touche par touche qu'en laissant appuyé
	move.w	#$AFFF,d7
 pausebcl2:
	move.b	d0,ancd0	; quitte à ralentir autant que cela serve...
	dbra	d7,pausebcl2
 prts:
	movem.l	(a7)+,a0-a2/d1/d3/d7
	rts
 ;****************** générateur de nombre pseudo-aléatoire *******************
 rand:
	move.l	d1,-(a7)
	move.w	rand_seed,d1
	mulu.w	#31421,d1
	add	#6927,d1
	mulu.w	d1,d0
	move.w	d1,rand_seed
	clr.w	d0
	swap	d0
	move.l	(a7)+,d1
	rts
 ;*************************** traçage de la grille ***************************
 grille:
	jsr	clrscr	; menu principal
	lea	tios::FontSetSys,a5
	lea	tios::DrawStrXY,a6
	move.w	#2,-(a7)	; empile la taille de caractères la plus grande
	jsr	(a5)	; appelle la fonction FontSetSys
	move.w	#4,-(a7)	; couleur
	pea	ca	; pointeur de la chaîne de caractère
	move.l	#$0017006F,-(a7)	; abscisse et ordonnée
	jsr	(a6)	; appelle la fonction
	addq	#2,a7	; restaure la pile de 2 car on ne change que le dernier paramètre
	move.w	#133,-(a7)	; empile l'abscisse 23+110=133
	jsr	(a6)	; appelle la fonction
	move.w	#1,-(a7)	; empile la taille de police moyenne
	jsr	(a5)	; appelle la fonction FontSetSys
	clr.l	cp
	moveq	#8,d7
 gcoord:
	moveq	#9,d6
	sub.w	d7,d6
	add.w	#48,d6
	move.w	d7,d5
	lsl.w	#3,d5
	add.w	#38,d5
	move.b	d6,cp
	move.w	#4,-(a7)
	pea	cp
	move.w	d5,-(a7)
	move.w	#114,-(a7)
	jsr	(a6) 
	dbra	d7,gcoord
	move.w	#$3130,cp
	move.w	#4,-(a7)
	pea	cp
	move.l	#$006F001E,-(a7)
	jsr	(a6)
	lea	100(a7),a7	; restaure la pile de (2+2+2+4)*10+2-2 car on garde l couleur
	pea	j1	; pointeur de la chaîne de caractère
	move.l	#$00020002,-(a7)	; abscisse et ordonnée
	jsr	(a6)	; appelle la fonction
	move.w	#4,-(a7)
	cmp.b	#1,nbrjoueurs
	beq	grordi
	pea	j2
	bra	grsuite
 grordi:
	pea	dernord
 grsuite:
	move.l	#$0002000C,-(a7)
	jsr	(a6)
	lea	32(a7),a7	; restaure la pile de 2+4+2+2=10 une fois par appel = 30+2 pour FontSetSys
	move.l	gray4lib::plane0,a2
	move.l	gray4lib::plane1,a3
	lea	graphlib::vert,a4
	lea	graphlib::horiz,a5
	move.l	a2,a1	; plane0
	moveq	#1,d7
	clr.w	d0
	clr.w	d1
	move.w	#239,d2
	moveq	#20,d3
	moveq	#2,d4
	jsr	mtr
 contour:
	clr	d0
	clr	d1
	move.w	#239,d2
	moveq	#2,d3	; en noir
	jsr	(a5)
	moveq	#10,d1
	jsr	(a5)
	moveq	#20,d1
	jsr	(a5)
	moveq	#127,d1
	jsr	(a5)
	clr.w	d2
	jsr	(a4)
	move.w	#239,d0
	jsr	(a4)
	moveq	#103,d0
	moveq	#19,d1
	jsr	(a4)
	clr	d5	; première grille
	move.l	a3,a1	; plane1
	dbra	d7,contour
	moveq	#1,d6
 grext:
	moveq	#29,d1
	moveq	#23,d2
	add	d5,d2
	add	d5,d0
	jsr	(a5)
	moveq	#109,d1
	jsr	(a5)
	moveq	#29,d2
	jsr	(a4)
	moveq	#23,d0
	add.w	d5,d0
	jsr	(a4)
	move.l	a2,a1	; plane0
	moveq	#8,d7
	addq	#1,d2
	subq	#1,d1
 grintv:
	add.w	#8,d0
	jsr	(a4)
	dbra	d7,grintv
	moveq	#8,d7
	moveq	#102,d0
	moveq	#109,d1
	moveq	#24,d2
	add	d5,d2
	add	d5,d0
 grinth:
	sub.w	#8,d1
	jsr	(a5)
	dbra	d7,grinth
	move.l	a3,a1	; plane1
	addq	#1,d0
	moveq	#110,d5
	dbra	d6,grext
	rts
 ;************ placement des bateaux dans la grille et la matrice ************
 place:
 ; input	a2.w = numéro de grille (0 ou 1)
 ;	a0.w = x (1..10)
 ;	a3.w = y (1..10)
 ;	a4.w = gauche(1) droite(2) haut(3) bas(4)
 ;	a5.w = longueur du bateau
 ;	c.w  = valeur à mettre dans la matrice
	movem.l	a0-a5,-(a7)
	move.w	a0,a	; a0 et a3 correspondent en fait aux coordonnées dans la matrice
	move.w	a3,b	; il faut donc trouver les coordonnées graphiques
 debutplace:
	cmp.w	#1,a4	; if a4=1
	bne	ifdroite	; then
	bsr	put	; place les bateaux dans la matrice
 bclgauche:
	sub.w	#1,a	; déplace dans la matrice
	cmp.w	#2,a5	; if a5=2
	beq	fingauche	; then goto fingauche
	sub.w	#1,a5	; else	
	bsr	put	; place les bateaux dans la matrice
	bra	bclgauche
 fingauche:
	bsr	put
 ifdroite:
	cmp.w	#2,a4	; if a4=2
	bne	ifhaut	; then	
	bsr	put	; place les bateaux dans la matrice
 bcldroite:
	add.w	#1,a	; déplace dans la matrice
	cmp.w	#2,a5	; if a5=2
	beq	findroite	; then goto findroite	
	sub.w	#1,a5	; else
	bsr	put	; place les bateaux dans la matrice
	bra	bcldroite
 findroite:
	bsr	put	; place les bateaux dans la matrice
 ifhaut:
	cmp.w	#3,a4	; if a4=3
	bne	ifbas	; then
	bsr	put	; place les bateaux dans la matrice
 bclhaut:
	add.w	#1,b	; déplace dans la matrice
	cmp.w	#2,a5	; if a5=2
	beq	finhaut	; then goto finhaut	
	sub.w	#1,a5	; else
	bsr	put	; place les bateaux dans la matrice
	bra	bclhaut
 finhaut:
	bsr	put	; place les bateaux dans la matrice
 ifbas:
	cmp.w	#4,a4	; if a4=4
	bne	endifbas	; then
	bsr	put	; place les bateaux dans la matrice
 bclbas:
	sub.w	#1,b	; déplace dans la matrice
	cmp.w	#2,a5	; if a5=2
	beq	finbas	; then goto finbas		
	sub.w	#1,a5	; else
	bsr	put	; place les bateaux dans la matrice
	bra	bclbas
 finbas:
	bsr	put	; place les bateaux dans la matrice
 endifbas:		; endif
	movem.l	(a7)+,a0-a5
	move.l	a0,a2
	move.b	nbrjoueurs,d7
	add.b	joueur,d7
	cmp.w	#1,d7
	beq	efb
	bsr	putspr
 efb:
	rts		; revient au programme principal
 ;************************* choisit le sens du bateau ************************
 batsens:
	bsr	getk
	tst.w	d0
	beq	batsens
	cmp.w	#5,d0
	bge	batsens
	move.w	d0,a4
	rts
;************************* vérification du placement ************************
 placetest:
 ; input:	a0.w = x (1..10)
 ;	a3.w = y (1..10)
 ;	a4.w = gauche(1) droite(2) haut(3) bas(4)
 ;	a5.w = longueur du bateau
 ;
 ; output:	erreur 1 si mauvais placement 0 sinon
	move.w	d0,-(a7)
	clr.b	erreur	; il n'y a pas d'erreur a priori
 ; on vérifie d'abord que les bateaux ne sortent pas de la grille
	cmp.w	#1,a4
	beq	thoriz	; va à thoriz si vers la droite sinon continue
	cmp.w	#2,a4
	bne	tvert	; on sait que à partir de la ligne suivante le bateau est vers la droite
	move.w	a0,d0	; envoie x dans d0
	add.w	a5,d0	; additionne la longueur à x
	sub.w	#1,d0	; coordonnées de la dernière case du bateau <11
	cmp.w	#11,d0
	bge	testrate
	move.w	d0,d1
	move.w	a0,d0
	move.w	a3,d2
	move.w	d2,d3
	bsr	tstbat
	bra	testok
 thoriz:		; si le bateau va vers la gauche
	move.w	a0,d0	; envoie x dans d0
	add.w	#10,d0	; ajoute 10 à d0
	sub.w	a5,d0	; soustrait la longueur à x
	add.w	#1,d0	; coordonnées de la dernière case du bateau >10
	cmp.w	#10,d0
	ble	testrate
	sub.w	#10,d0
	move.w	a0,d1
	move.w	a3,d2
	move.w	d2,d3
	bsr	tstbat
	bra	testok
 tvert:
	cmp.w	#3,a4
	bne	tbas	; va à tbas si vers le bas sinon continue
	move.w	a3,d0	; envoie y dans d0
	add.w	a5,d0	; additionne la longueur à y
	sub.w	#1,d0	; coordonnées de la dernière case du bateau <11
	cmp.w	#11,d0
	bge	testrate
	move.w	d0,d3
	move.w	a0,d0
	move.w	d0,d1
	move.w	a3,d2
	bsr	tstbat
	bra	testok
 tbas:
	move.w	a3,d0	; envoie y dans d0
	add.w	#10,d0	; ajoute 10 à d0
	sub.w	a5,d0	; soustrait la longueur à y
	add.w	#1,d0	; coordonnées de la dernière case du bateau >10
	cmp.w	#10,d0
	ble	testrate
	sub.w	#10,d0
	move.w	d0,d2
	move.w	a0,d0
	move.w	d0,d1
	move.w	a3,d3
	bsr	tstbat
	bra	testok
 ; on teste maintenant si les bateaux ne se touchent ni ne se chevauchent
 tstbat:
 ; input: 	d0.w = xmin
 ; 	d1.w = xmax
 ; 	d2.w = ymin
 ; 	d3.w = ymax
	move.w	d0,d4
	sub.w	#1,d4
	move.w	d2,d5
	sub.w	#1,d5
	sub.w	d0,d1
	add.w	#2,d1
	move.w	d1,d0
	sub.w	d2,d3
	add.w	#2,d3
 lbltst1:
	move.w	d0,d1
 lbltst2:
	move.w	d1,a
	add.w	d4,a
	move.w	d3,b
	add.w	d5,b
	jsr	get
	clr.l	d6
	move.w	c,d6
	tst.b	joueur	; if le joueur 1 est actif
	bne	tst1
	ror.w	#8,d6	; dans la matrice	d6.w = 	xxxxxxxx xxxxxxxx
	btst.b	#0,d6	; test du bit	.......x ........	
	bne	tstr
	bra	tstfin
 tst1:
	btst.b	#0,d6	; test du bit	........ .......x	
	bne	tstr	
	bra	tstfin
 tstr:
	move.b	#1,erreur
	bra	tstfin2
 tstfin:
	dbra	d1,lbltst2	; teste toutes les cases en contact, c'es à dire
	dbra	d3,lbltst1	; longueur du bateau*3+6 cases
 tstfin2:
	rts
 testrate:
	move.b	#1,erreur	; si le placement est non autorisé
 testok:
	move.w	(a7)+,d0
	rts
 ;************************* écriture dans la matrice *************************
 put:
 ; input:
 ; put (a.w,b.w)
 ; c.w = valeur à ajouter
	movem.l 	a0/d0-d2,-(a7)
	lea	matrice,a0	; on charge l'adresse du tableau dans A0
	move.w	a,d0	; on veut la a-ème colonne
	move.w	b,d1	; on veut la b-ème ligne
	mulu.w	#12,d1	; il y a 12 éléments par ligne
	add.l	d1,d0	; on ajoute les indices de ligne et colonne
	lsl.l	#1,d0	; notre tableau est composé de mots
	move.w	c,d2
	or.w	d2,0(a0,d0)	; effectue un OU logique avec c aux coordonnées (a,b)
	movem.l 	(a7)+,a0/d0-d2
	rts
 ;****************************** lit la matrice ******************************
 get:
 ; input:
 ; put (a.w,b.w)
 ; 
 ; output:
 ; c.w = valeur lue à matrice(a,b)
	movem.l 	a0-a6/d0-d7,-(a7)
	lea	matrice,a0	; on charge l'adresse du tableau dans A0
	move.w	a,d0	; on veut la a-ème colonne
	move.w	b,d1	; on veut la b-ème ligne
	mulu.w	#12,d1	; il y a 12 éléments par ligne
	add.l	d1,d0	; on ajoute les indices de ligne et colonne
	lsl.l	#1,d0	; notre tableau est composé de mots
	move.w	0(a0,d0),c	; met la valeur lue dans c
	movem.l 	(a7)+,a0-a6/d0-d7
	rts
 ;***************************** place les sprites ****************************
 putspr:
	movem.l 	a0-a6/d0-d7,-(a7)
 ; input	
 ;	a2.w = x (1..10)
 ;	a3.w = y (1..10)
 ;	a4.w = gauche(1) droite(2) haut(3) bas(4)
 ;	a5.w = longueur du bateau
	moveq	#2,d2
	moveq	#2,d3
	cmp.w	#3,a4
	bne	putnxt
	add.w	a5,a3	; si le bateau va vers le haut, on ajoute sa longueur à y
	bra	putokv
 putnxt:
	cmp.w	#1,a4
	bne	putnxt2
	sub.w	a5,a2	; si il va vers la gauche, on soustrait sa longueur à x
	add.w	#1,a2
	add.w	#1,a3
	bra	putokh
 putnxt2:
	add.w	#1,a3
	cmp.w	#2,a4	; va vers la droite?
	bne	putokv
	beq	putokh
 putokh:
	cmp.w	#5,a5	; porte-avions
	bne	ptspr1h
	moveq	#3,d2
	moveq	#5,d3
	lea	phc(pc),a4
	lea	phf(pc),a5
	lea	phm(pc),a6
	bra	ptspr0
 ptspr1h:
	cmp.w	#4,a5	; frégate
	bne	ptspr2h
	moveq	#4,d3
	move.w	#3,d2
	lea	fhc(pc),a4
	lea	fhf(pc),a5
	lea	fhm(pc),a6
	bra	ptspr0
 ptspr2h:
	cmp.w	#3,a5	; destroyers
	bne	ptspr3h
	moveq	#4,d3
	lea	shc(pc),a4
	lea	shf(pc),a5
	lea	shm(pc),a6
	bra	ptspr0
 ptspr3h:
	moveq	#1,d2
	moveq	#3,d3
	lea	nhc(pc),a4	; sous-marin
	lea	nhf(pc),a5
	lea	nhm(pc),a6
	bra	ptspr0
 putokv:
	cmp.w	#5,a5	; porte-avions
	bne	ptspr1
	moveq	#4,d2
	moveq	#5,d3
	lea	pvc(pc),a4
	lea	pvf(pc),a5
	lea	pvm(pc),a6
	bra	ptspr0
 ptspr1:
	cmp.w	#4,a5	; frégate
	bne	ptspr2
	moveq	#5,d3
	lea	fvc(pc),a4
	lea	fvf(pc),a5
	lea	fvm(pc),a6
	bra	ptspr0
 ptspr2:
	moveq	#4,d3
	cmp.w	#3,a5	; destroyers
	bne	ptspr3
	lea	svc(pc),a4
	lea	svf(pc),a5
	lea	svm(pc),a6
	bra	ptspr0
 ptspr3:
	moveq	#1,d2
	moveq	#3,d3
	lea	nvc(pc),a4	; sous-marin
	lea	nvf(pc),a5
	lea	nvm(pc),a6
	bra	ptspr0
 ptspr0:
	move.w	a2,d0	; met x dans d0
	sub.w	#1,d0
	lsl.w	#3,d0
	add.w	#24,d0	; obtient les coordonnées du sprite
	sub.w	d2,d0
	move.b	joueur,d2
	tst.w	d2
	bne	ptstr00
	add.w	#110,d0	; choisit la grille en fonction du joueur
 ptstr00:	
	move.w	a3,d1	; met y dans d1
	moveq	#10,d4
	sub.w	d1,d4
	move.w	d4,d1
	lsl.w	#3,d1
	add.w	#40,d1	; obtient les coordonnées du sprite
	sub.w	d3,d1
	moveq	#1,d4	; pour masquer en blanc -> effacer !!
	move.l	gray4lib::plane1,a1
	movem.w 	d0-d7,-(a7)
	jsr	(a6)	; pseudo-masque
	bsr	mtr
	movem.w 	(a7)+,d0-d7
	move.l	gray4lib::plane0,a1 
	movem.w 	d0-d7,-(a7)
	jsr	(a6)	; pseudo-masque
	bsr	mtr
	movem.w 	(a7)+,d0-d7
	move.l	gray4lib::plane1,a1
	move.l	a5,a0	; addresse du sprite
	move.l	a0,a2	; les sprites sont leurs propres masques
	add.w	#4,a2	; il faut juste sauter les dimensions du sprite
	clr.w	d3
	jsr	graphlib::put_sprite2
	move.l	gray4lib::plane0,a1
	move.l	a4,a0	; addresse du sprite
	move.l	a0,a2
	add.w	#4,a2
	clr.w	d3
	jsr	graphlib::put_sprite2
	movem.l 	(a7)+,a0-a6/d0-d7
	rts
 ;****************************** pseudo-masques ******************************
 ; pour mes sprites, il m'aurait fallu environ 1240 octets de masques... je préfère comme çà :o)
 ; là ça prend dans les 340 octets soit environ 900 octets d'économie !
 ; input:	d0.w = x
 ;	d1.w = y
 mtr:		; fait gagner plein de place mais plus lent...
	jsr	graphlib::fill
	rts
 phm:
	addq	#2,d0
	addq	#2,d1
	moveq	#40,d2
	moveq	#8,d3
	bsr	mtr
	moveq	#14,d2
	moveq	#10,d3
	bsr	mtr
	add.w	#27,d0
	add.w	#8,d1
	moveq	#15,d2
	moveq	#2,d3
	bsr	mtr
	add.w	#13,d0
	sub.w	#9,d1
	clr.w	d2
	clr.w	d3
	rts
 fhm:
	addq	#2,d0
	addq	#2,d1
	moveq	#32,d2
	moveq	#6,d3
	bsr	mtr
	add.w	#28,d0
	addq	#7,d1
	moveq	#2,d2
	clr.w	d3
	bsr	mtr
	subq	#4,d0
	sub.w	#8,d1
	clr.w	d2
	rts
 shm:
	addq	#1,d0
	addq	#2,d1
	move	#22,d2
	moveq	#6,d3
	bsr	mtr
	add.w	#24,d0
	addq	#3,d1
	clr.w	d2
	moveq	#1,d3
	bsr	mtr
	sub.w	#9,d0
	subq	#4,d1
	clr.w	d3
	rts
 nhm:
	add.w	#8,d0
	addq	#1,d1
	clr.w	d2
	moveq	#6,d3
	bsr	mtr
	add.w	#8,d0
	addq	#3,d1
	clr.w	d3
	rts
 pvm:
	addq	#1,d0
	addq	#2,d1
	moveq	#10,d2
	moveq	#8,d3
	bsr	mtr
	addq	#1,d0
	add.w	#9,d1
	moveq	#9,d2
	moveq	#31,d3
	bsr	mtr
	add.w	#32,d1
	clr.w	d3
	moveq	#5,d2
	bsr	mtr
	addq	#5,d0
	subq	#1,d1
	bsr	mtr
	addq	#5,d0
	sub.w	#32,d1
	clr.w	d2
	rts
 fvm:
	addq	#2,d0
	addq	#2,d1
	moveq	#6,d2
	moveq	#32,d3
	bsr	mtr
	add.w	#23,d1
	moveq	#7,d2
	moveq	#2,d3
	bsr	mtr
	add.w	#11,d1
	moveq	#4,d2
	clr.b	d3
	bsr	mtr
	subq	#1,d0
	subq	#6,d1
	clr.w	d2
	moveq	#2,d3
	rts
 svm:
	addq	#2,d0
	addq	#2,d1
	moveq	#6,d2
	moveq	#22,d3
	bsr	mtr
	addq	#1,d0
	add.w	#14,d1
	clr.w	d3
	bsr	mtr
	addq	#2,d0
	add.w	#9,d1
	clr.w	d2
	rts
 nvm:
	addq	#1,d0
	add.w	#8,d1
	moveq	#6,d2
	clr.w	d3
	bsr	mtr
	addq	#2,d0
	add.w	#8,d1
	moveq	#2,d2
	rts
 ;****************************** curseur du menu *****************************
 menucurseur:
	cmp.b	#-1,d5
	beq	mcrs1
	cmp.w	#3,d5
	beq	mcrs2
	bra	mcrs0
 mcrs1:
	moveq	#2,d5
	bra	mcrs0
 mcrs2:
	clr.w	d5
 mcrs0:
	move.w	d5,d1
	mulu.w	#20,d1
	add.w	#40,d1
	moveq	#21,d0
	move.w	#197,d2
	moveq	#18,d3
	clr.w	d4
	jsr	mtr
	moveq	#4,d7
 cbcl:		; on calme un peu plus...
	jsr	wait
	dbra	d7,cbcl
	rts
 ;******************************* pour le retour *****************************
 prepback:
	jsr	gray4lib::off	; désactive le niveau de 4 gris
	move.l	#$600001,a0
	move.w	#$700,d0	; permet d'abords de détourner l'int1
	trap	#1	; (voir au début du code) pour pouvoir afficher 
	bclr.b	#2,(a0)	; des niveaux de gris qui ne flashent pas quand
	move.l	old_int1,$64	; on teste la matrice clavier, puis la remet
	bset.b	#2,(a0)	; en place (ici).
	clr.w	d0
	trap	#1
	rts
 ;**************************** tir de l'ordinateur ***************************
 ; là c'est la partie la plus rigolote...
 ; input:	tch.w
 ;	cle.w
 ;	xr
 ;	yr
 ;	rtir
 ;	sens...
 ;
 ; output:	x.w
 ;	y.w
 ;	xr
 ;	yr
 ;	rtir
 ;	sens...
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 sprg1:
	move.w	xr,x	; le bateau est touché pour la première fois
	move.w	yr,y	; en (x,y) que l'on a sauvegardées en (xr,yr)
		; on tire alors en (xr+1,yr),(xr,yr+1),(xr-1,yr) ou (xr,yr-1)
	bsr	sprg10	; tout en vérifiant que le tir est valide
	bsr	sprg3
	tst.b	erreur
	bne	sprg1
	rts
 sprg10:
	moveq	#4,d0
	bsr	rand
	cmp.w	#1,d0
	beq	sg11
	cmp.w	#2,d0
	beq	sg12
	cmp.w	#3,d0
	beq	sg13
	add.w	#1,x
	move.w	yr,y
	rts
 sg11:
	sub.w	#1,x
	move.w	yr,y
	rts
 sg12:
	add.w	#1,y
	move.w	xr,x
	rts
 sg13:
	sub.w	#1,y
	move.w	xr,x
	rts
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 sprg20:
	moveq	#5,d0	; nombre entre 1 et 5
	bsr	rand
	add.w	#1,d0
	lsl.w	#1,d0	; entre 2 et 10
	rts
 sprg2:
	clr.b	erreur	; tire au hasard tout en intercalant les cases
	moveq	#10,d0	; en effet, le blus petit bateau faisant deux cases de
	bsr	rand	; long, il ne sert à rien de tirer sur toutes les cases
	move.w	d0,y
	add.w	#1,y	; entre 1 et 10
	bsr	sprg20
	move.w	d0,x
	move.w	y,d0
	add.w	tircte,d0
	btst.b	#0,d0
	beq	sg2
	sub.w	#1,x
 sg2:
	bsr	sprg3	; vérifie si le tir est valide
	tst.b	erreur
	bne	sprg2
	clr.w	rtir
	rts
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 sprg3:
	clr.b	erreur	; vérifie la validité de la case
	tst.w	x
	beq	sprg31
	cmp.w	#11,x
	beq	sprg31
	tst.w	y
	beq	sprg31
	cmp.w	#11,y
	beq	sprg31
	move.w	x,a
	move.w	y,b
	bsr	get	; lit la matrice à (x=a,y=b)
	or.w	#%1111110111111111,c	; il ne faut pas y avoir déjà tiré
	cmp.w	#$FFFF,c
	bne	sg30
 sprg31:
	move.b	#1,erreur
 sg30:
	rts
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 sg42:
	tst.b	sens
	beq	sg422
 sg421:
	move.w	xr,x
	add.w	d1,x
	sub.w	#4,x
	move.w	yr,y
	bra	sg423
 sg422:
	move.w	yr,y
	add.w	d1,y
	sub.w	#4,y
	move.w	xr,x
 sg423:
	rts
 sg43:
	move.w	x,a
	move.w	y,b
	rts
 sprg4:		; on a déja touché le bateau deux fois, et on connait son sens
		; on tire donc dans l'alignement, de plus en plus loin jusqu'à
	moveq	#4,d1	; ce que le bateau soit coulé ou que l'ou trouve de l'eau,
	moveq	#2,d0	; auquel cas on tire de l'autre côté de (xr,yr)
	bsr	rand	; il n'y a pas de préférence pour tirer à gauche ou à
	tst.w	d0	; droite de (xr,yr), alors... rand
	beq	sg410
 sg400:
	add.w	#1,d1
	bsr	sg42
	bsr	sg43
	bsr	get
	or.w	#%1111110111111111,c	; continue si on a déjà tiré sur la case et qu'on y a touché un
	cmp.w	#$FFFF,c	; bateau, retourne si on n'y a pas tiré, change de sens si on y
	bne	sg409	; a déjà tiré dans l'eau
	bsr	get
	or.w	#%1111111111111110,c
	cmp.w	#$FFFF,c
	beq	sg400
 sg401:
	moveq	#4,d1
 sg402:
	sub.w	#1,d1
	bsr	sg42
	bsr	sg43
	bsr	get
	or.w	#%1111110111111111,c
	cmp.w	#$FFFF,c
	bne	sg409
	bra	sg402
 sg409:
	rts	
 sg410:
	sub.w	#1,d1
	bsr	sg42
	bsr	sg43
	bsr	get
	or.w	#%1111110111111111,c
	cmp.w	#$FFFF,c
	bne	sg409
	bsr	get
	or.w	#%1111111111111110,c
	cmp.w	#$FFFF,c
	beq	sg410
 sg411:
	moveq	#4,d1
 sg412:
	add.w	#1,d1
	bsr	sg42
	bsr	sg43
	bsr	get
	or.w	#%1111110111111111,c
	cmp.w	#$FFFF,c
	bne	sg409
	bra	sg412
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 sprg9:
	clr.b	sens	; si xr=x alors le bateau est horizontal,
	move.w	x,d0	; sinon il est vertical
	cmp.w	xr,d0
	beq	sg90
	move.b	#1,sens
 sg90:
	rts
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 tirordi:
	tst.w	tch
	bne	t00
 t01:
	tst.w	rtir	; on a raté au coup précédent
	beq	t05	; rtir=0: pas de bateau non coulé connu
		; rtir=1: on a touché une seule fois le bateau à (xr,yr)
 t06:		; rtir=2: on a touché le bateau au moins deux fois sans le couler
	bsr	t1	; rtir>0
 t04:
	rts
 t05:		; rtir=0
	bsr	sprg2	; tire au hasard
	rts
 t00:
	tst.w	rtir	; on a touché au coup précédent
	beq	t02
	cmp.w	#1,rtir
	beq	t03
 t08:		; rtir>0
	bsr	t3
	rts
 t03:		; rtir=1
	bsr	t2
	rts
 t02:
	move.w	#1,rtir	; on a touché pour la première fois :o)
	move.w	x,xr	; on sauvegarde (x,y) en (xr,yr)
	move.w	y,yr	; et on tire dans une case adjacente valide
	bsr	sprg1
	rts
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 t1:
	cmp.w	#2,rtir	; tir précédent raté et rtir>0
	beq	t11
 t10:		; rtir=1
	bsr	sprg1
	rts
 t11:		; rtir=2
	bsr	sprg4
	rts
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 t2:
	tst.w	cle	; on recommence à zéro si le bateau a été coulé
	beq	t21
 t20:
	bsr	sprg2
	rts
 t21:
	bsr	sprg9	; sinon, on a touché le bateau une deuxième fois :o)))
	bsr	sprg4
	move.w	#2,rtir
	rts
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 t3:
	tst.w	cle	; on vérifie que le bateau n'est pas encore coulé
	bne	t30
 sg31:
	bsr	sprg4	; on continue à frapper...
	rts
 t30:
	bsr	sprg2
	rts
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;************************** fin des sous-programmes *************************
 ;****************************************************************************
_main:		; c'est ici que la lecture du code commence
 ;**************************** début du programme ****************************
	even
 seawar:
	move.l	a7,save	; sauvegarde le pointeur de la pile utilisateur
		; réinitialisation des variables
	move.w	#288-2,d2	; il y a 144 cases dans la matrice
		; 10*10 entourées d'un "carré de sécurité"
 efmat1:		; d'une ligne d'épaisseur (ça simplifie drôlement le code!!!)
		; donc la matrice est 12*12
	lea	matrice,a0	; on charge l'adresse du tableau dans a0
	clr.b	0(a0,d2)	; on efface le mot à 0+a0+d0
	dbra	d2,efmat1	; efface toute la matrice
	move.w	#1,a
	moveq	#9,d2
	move.w	#%0000001000000010,c
 efmat10:
	clr.w	a	; fait en sorte qu'il soit impossible de tirer
	move.w	d2,b	; dans la bordure de la matrice
	bsr	put	; sinon l'ordinateur le ferait...
	move.w	#11,a
	bsr	put
	clr.w	b
	move.w	d2,a
	bsr	put
	move.w	#11,b
	bsr	put
	dbra	d2,efmat10
	move.l	#$01010101,u1
	clr.l	tot1	; efface tot1 et tot2
	clr.w	vdpl	; efface vdpl et hdpl
	clr.b	sel
	moveq	#4,d2
 efmat2:		; on réinitialise aussi les listes de longueurs restantes des bateaux
	lea	longbat,a0	; on charge l'adresse du tableau dans a0
	move.l	d2,d0	; on veut la d2-ème valeur
	lsl.l	#1,d0	; la liste contient des mots
	move.w	0(a0,d0),d3	; on enregistre le contenu de la d3-ème valeur dans d3
	add.w	d3,tot1	; nombre de cases total
	add.w	d3,tot2	
	lea	batj1,a0	; on charge l'adresse du tableau dans a0
	move.w	d3,0(a0,d0)	; on enregistre le contenu de d3 dans la liste
	lea	batj2,a0	; on charge l'adresse du tableau dans a0
	move.w	d3,0(a0,d0)	; on enregistre le contenu de d3 dans la liste
	dbra	d2,efmat2
	move.l	#$600116,a6	; sans cela, rand_seed serait toujours le même à chaque premier jeu
	move.w	(a6),d0
	move.w	$6000D6,rand_seed	; j'ai vu que l'octet à $6000D7 et celui à 
		; $600116 bouge tout le temps mais je ne sais
	add.w	d0,rand_seed	; pas à quoi ils correspondent... si quelqu'un sait... timer?
	moveq	#2,d0
	bsr	rand
	move.w	d0,tircte
	bsr	sprg2
	move.w	#$700,d0	; aucun int
	move.l	#$600001,a0
	trap	#1
	bclr.b	#2,(a0)	; déprotège la mémoire basse
	move.l	$64,old_int1	; sauvegarde l'ancien vecteur
	move.l	#newint1,$64	; nouveau vecteur
	bset.b	#2,(a0)	; reprotège la mémoire basse
	clr.w	d0
	trap	#1	; remet les ints
	move.w	#1,graphlib::choosescreen	;affiche dans l'écran dont l'addresse est dans a1
	jsr	gray4lib::on	; active le niveau de 4 gris
	jsr	clrscr	; menu principal
	moveq	#1,d7
	lea	graphlib::horiz,a5
	lea	graphlib::vert,a6
 tracemenu1:
	clr.w	d0
	clr.w	d1
	moveq	#127,d2
	jsr	(a6)
	move.w	#239,d0
	jsr	(a6)
	moveq	#20,d0
	moveq	#39,d1
	moveq	#99,d2
	jsr	(a6)
	move.w	#219,d0
	jsr	(a6)
	clr.w	d0
	clr.w	d1
	move.w	#239,d2
	moveq	#2,d3
	jsr	(a5)
	moveq	#19,d1
	jsr	(a5)
	moveq	#127,d1
	jsr	(a5)
	moveq	#3,d6
	moveq	#20,d0
	moveq	#19,d1
	move.w	#219,d2
 tracemenu2:
	add.w	#20,d1
	jsr	(a5)
	dbra	d6,tracemenu2
	move.l	gray4lib::plane0,a1
	dbra	d7,tracemenu1
	lea	tios::DrawStrXY,a6
	move.w	#2,-(a7)	; empile taille de la police
	jsr	tios::FontSetSys	; appelle la fonction
	move.w	#4,-(a7)	; couleur
	pea	titre(pc)	; pointeur de la chaîne de caractère
	move.l	#$00640005,-(a7)	; abscisse,ordonnée
	jsr	(a6)	; appelle la fonction
	move.w	#4,-(a7)
	pea	unjoueur(pc)
	move.l	#$0032002C,-(a7)
	jsr	(a6)	
	move.w	#4,-(a7)
	pea	deuxjoueurs	(pc)
	move.l	#$00230040,-(a7)
	jsr	(a6)
	move.w	#4,-(a7)
	pea	quitter(pc)
	move.l	#$005F0054,-(a7)
	jsr	(a6)
	lea	42(a7),a7	; restaure la pile de 2+(2+4+4)*4=42
	move.l	gray4lib::plane0,a1	; facultatif sur ti-92, mais indispensable sur 92+... alors je le
	clr.w	d0	; laisse pour faciliter la compatibilité...
	clr.w	d1
	move.w	#239,d2
	moveq	#19,d3
	moveq	#2,d4
	jsr	mtr
	clr.w	d5
 menubcl:
	bsr	menucurseur
 menugetk:
	bsr	getk
	cmp.w	#4,d0
	beq	basapp
	cmp.w	#3,d0
	beq	hautapp
	cmp.w	#5,d0
	beq	enterapp
	bra	menugetk
 hautapp:
	bsr	menucurseur
	subq	#1,d5
	bra	menubcl
 basapp:
	bsr	menucurseur
	addq	#1,d5
	bra	menubcl
 enterapp:
	cmp.w	#2,d5
	beq	fin2
	addq	#1,d5
	move.b	d5,nbrjoueurs	; fin du menu principal
	clr.w	x	; cle,tch,x,y,xr et yr sont ici utilisées comme variables temporaires
	move.b	#1,joueur
 deb:
	bsr	grille	; trace la grille
 j1place:
	moveq	#4,d7	; nombre de bateaux à placer-1
 j1placebcl:
	move.w	d7,xr
	move.w	d7,cle	; sauvegarde la longueur
	move.w	d7,yr	; cette partie du code est très obscure... je ne me comprends plus...
	add.w	#2,yr	; il faudra que je revoie tout celà un de ces quatres...
	lea	longbat(pc),a0	; on charge l'adresse du tableau dans a0
	move.l	d7,d0	; on veut la d7-ème valeur
	lsl.w	#1,d0	; la liste contient des mots
	move.w	0(a0,d0),y	; on enregistre le contenu de la a5-ème valeur dans y
	move.w	#0,a5	; dans la grille de gauche
	tst.b	joueur
	bne	s1
	move.w	#1,a5
 s1:
	bsr	selec	; sous programme pour séléctionner une case de la grille
	cmp.w	#1,a4	; test a4
 j1lbl:
	move.w	a3,a0	; x
	move.w	a2,a3	; y
	bsr	batsens	; sous programme pour choisir le sens du bateau à placer
	move.w	#0,a2	; grille
	move.w	y,a5	; charge la longueur
	bsr	placetest	; sous programme pour vérifier le placement
	tst.b	erreur
	beq	paserr1
	move.w	xr,d7
	move.w	d7,tch
	moveq	#8,d7
 ws2:
	bsr	wait	; on calme un peu plus...
	dbra	d7,ws2
	move.w	tch,d7
	bra	j1placebcl
 paserr1:
	move.w	#%0000000000000001,c
	movem.l	a0-a6/d0-d7,-(a7)
	move.w	c,d5
	move.w	yr,d7
	moveq	#%0000000000000001,d6
	rol.w	d7,d6
	or.w	d6,d5
	move.w	d5,c
	movem.l 	(a7)+,a0-a6/d0-d7
	tst.b	joueur
	bne	s2
	move.w	#%0000000100000000,c
	movem.l 	a0-a6/d0-d7,-(a7)
	move.w	c,d5
	move.w	yr,d7
	move.w	#%0000000100000000,d6
	rol.w	d7,d6
	or.w	d6,d5
	move.w	d5,c
	movem.l 	(a7)+,a0-a6/d0-d7
 s2:
	bsr	place	; sous programme pour placer les bateaux à l'écran et dans la matrice
	moveq	#8,d7
 ws1:
	bsr	wait	; on calme un peu plus...
	dbra	d7,ws1
	move.w	cle,d7	; restitue la longueur
	dbra	d7,j1placebcl	; effectue la boucle 5 fois
	bsr	putspr
	cmp.b	#2,nbrjoueurs
	bne	ordiplace
	clr.b	joueur
	tst.w	x
	bne	pretir
	move.w	#1,x
	bra	deb
 ordiplace:
	clr.b	joueur
	moveq	#4,d7	; nombre de bateaux à placer-1
 ordiplacebcl:
	move.w	d7,xr
	move.w	d7,yr
	add.w	#2,yr
	lea	longbat(pc),a0	; on charge l'adresse du tableau dans a0
	move.l	d7,d0	; on veut la d7-ème valeur
	lsl.l	#1,d0	; la liste contient des mots
	move.w	0(a0,d0),y	; on enregistre le contenu de la a5-ème valeur dans y
	move.w	#1,a5	; dans la grille de droite
	moveq	#10,d0
	bsr	rand
	add.w	#1,d0
	move.w	d0,a2	; génère y aléatoirement
	moveq	#10,d0
	bsr	rand
	add.w	#1,d0
	move.w	d0,a3	; génère x aléatoirement
 ordilbl:
	move.w	a3,a0	; x
	move.w	a2,a3	; y
	moveq	#4,d0
	bsr	rand
	add.w	#1,d0
	move.w	d0,a4	; génère le sens aléatoirement
	move.w	#1,a2	; grille de droite
	move.w	y,a5	; charge la longueur
	bsr	placetest	; sous programme pour vérifier le placement
	move.w	y,a5
	tst.b	erreur
	beq	paserr2
	move.w	xr,d7
	bra	ordiplacebcl
 paserr2:
	move.w	#%0000000100000000,c
	movem.l	a0-a6/d0-d7,-(a7)
	move.w	c,d5
	move.w	yr,d7
	move.w	#%0000000100000000,d6
	rol.w	d7,d6
	or.w	d6,d5
	move.w	d5,c
	movem.l	(a7)+,a0-a6/d0-d7	; il y a une fuite de la pile quelque part... où?
	bsr	place	; sous programme pour placer les bateaux à l'écran et dans la matrice
	move.w	xr,d7
	dbra	d7,ordiplacebcl	; effectue la boucle 5 fois
 pretir:
	clr.w	rtir
	clr.l	tch	; efface tch et cle
	clr.l	xr
	move.l	#$01010101,u1	; réinitialise u1
 tir:
	cmp.b	#1,nbrjoueurs
	beq	txr
	bsr	grille
 txr:
	move.l	gray4lib::plane0,a1 	; séléctionne l'écran gris clair
	moveq	#1,d0
	moveq	#11,d1
	moveq	#101,d2
	moveq	#8,d3
	moveq	#1,d4
	bsr	mtr
 tir1:		; tir joueur
	movem.l 	a0-a6/d0-d7,-(a7)
	move.l	gray4lib::plane0,a1 	; séléctionne l'écran gris clair
	moveq	#1,d0
	moveq	#1,d1
	moveq	#101,d2
	moveq	#8,d3
	clr.w	d4
	bsr	mtr
	moveq	#11,d1
	bsr	mtr
	move.l	gray4lib::plane1,a1 	; séléctionne l'écran gris foncé
	moveq	#1,d4
	moveq	#104,d0
	move.w	#2,d1
	move.w	#134,d2
	moveq	#7,d3
	tst.b	joueur
	beq	tgf
 tg1:
	add.w	#10,d1
 tgf:
	bsr	mtr
	move.w	#4,-(a7)	; empile la couleur
	pea	chcase(PC)	; empile le pointeur de la chaîne de caractère
	move.w	d1,-(a7)	; empile l'ordonnée
	move.w	#108,-(a7)	; empile l'abscisse
	jsr	tios::DrawStrXY	; appelle la fonction
	lea	10(a7),a7	; restaure la pile de 2+4+2+2=10
	movem.l 	(a7)+,a0-a6/d0-d7
 tirj00:
	move.w	#1,a5
	tst.b	joueur
	beq	tirj0
	move.w	#0,a5
	bra	tirj0	
 tirj0:
	cmp.b	#2,nbrjoueurs
	bne	tira
 tja:
	bsr	selec
	move.w	a3,a
	move.w	a2,b
	bra	tirb
 tira:
	tst.b	joueur
	beq	tja
	move.w	x,a
	move.w	y,b
 tirb:
	bsr	get
	move.w	c,d6
	move.w	#%1111110111111111,d7	; a-ton déja tiré ici ?
	tst.b	joueur
	bne	tirj2
	move.w	#%1111111111111101,d7	; si le joueur 2 est actif
 tirj2:
	or.w	d7,d6	; teste le bit ......x.
	cmp.w	#%1111111111111111,d6
	beq	tirj00	; recommence si le joueur a déja tiré ici
		; à partir d'ici on sait que la case est valide
	move.w	#%1111111011111111,d7	; y a-til un bateau averse ici ?
	tst.b	joueur
	beq	tirj1
	move.w	#%1111111111111110,d7
 tirj1: 
	bsr	get	; on teste maintenant s'il y avait un bateau dans la case
	move.w	c,d6
	or.w	d7,d6
	move.w	#2,a6
	tst.b	joueur
	beq	tf01
	add.w	#10,a6
 tf01:
	movem.l 	a0-a6/d0-d7,-(a7)
	move.l	gray4lib::plane1,a1
	move.w	#2,a6	; affiche les coordonnées du tir
	tst.b	joueur
	beq	pcd1
	add.w	#10,a6
 pcd1:
	moveq	#1,d4
	moveq	#104,d0
	move.w	a6,d1
	move.w	#134,d2
	moveq	#7,d3
	bsr	mtr
	lea	tcor,a0
	move.w	b,d6
	add.b	#48,d6
	moveq	#32,d7
	cmp.b	#58,d6
	bne	pcn
	move.b	#48,d7
	move.b	#49,d6
 pcn:
	move.w	a,d5
	add.b	#64,d5
	move.b	d5,(a0)
	move.b	d6,2(a0)	; crée la chaîne à afficher: d5,"-",d6,d7,0
	move.b	d7,3(a0)
	move.w	#4,-(a7)	; empile la couleur
	move.l	a0,-(a7)	; empile le pointeur de la chaîne de caractère
	move.w	a6,-(a7)	; empile l'ordonnée
	move.w	#108,-(a7)	; empile l'abscisse
	jsr	tios::DrawStrXY	; appelle la fonction
	lea	10(a7),a7
	movem.l 	(a7)+,a0-a6/d0-d7
	move.w	a,d0	; met x dans d0
	sub.w	#1,d0
	lsl.w	#3,d0
	add.w	#30,d0	; obtient les coordonnées du sprite
	sub.w	d2,d0
	move.b	joueur,d2
	tst.w	d2
	bne	ptstr000
	add.w	#110,d0	; choisit la grille en fonction du joueur
 ptstr000:
	tst.b	joueur
	beq	pt2
	cmp.b	#2,nbrjoueurs
	beq	pt2
 	add.w	#2,d0
 pt2:
	move.w	b,d1	; met y dans d1
	moveq	#10,d4
	sub.w	d1,d4
	move.w	d4,d1
	lsl.w	#3,d1
	add.w	#30,d1	; obtient les coordonnées du sprite
	movem.l	d0-d1,-(a7)
	cmp.w	#%1111111111111111,d6	; test s'il y a un bateau adverse dans la case
	beq	atouche	; dans l'eau !!
	move.w	#4,-(a7)	; empile la couleur
	pea	dansleau(PC)	; empile le pointeur de la chaîne de caractère
	move.w	a6,-(a7)	; empile l'ordonnée
	move.w	#133,-(a7)	; empile l'abscisse
	jsr	tios::DrawStrXY	; appelle la fonction
	lea	10(a7),a7	; restaure la pile de 2+4+2+2=10
	tst.b	joueur
	beq	nc3
	clr.w	tch
	clr.w	cle
 nc3:
	move.l	gray4lib::plane1,a1
	lea	tir2f,a0
	movem.l	(a7)+,d0-d1
	jsr	graphlib::put_sprite
	move.l	gray4lib::plane0,a1
	lea	tir2c,a0
	jsr	graphlib::put_sprite
	bra	tirx1
 atouche:
	movem.l	(a7)+,d0-d1
	move.l	gray4lib::plane1,a1
	lea	tirf,a0
	jsr	graphlib::put_sprite
	move.l	gray4lib::plane0,a1
	lea	tirc,a0
	jsr	graphlib::put_sprite
	lea	batj2,a4
	moveq	#8,d4
	tst.b	joueur
	beq	tirx2
	clr.w	d4
	lea	batj1,a4
 tirx2:
		; on teste maintenant si le bateau a été coulé
 ; .....x..	 le bateau est ...	sous marin
 ; ....x...		destroyer
 ; ...x....		destroyer
 ; ..x.....		frégate
 ; .x......		porte-avions
	bsr	get
	move.w	c,d5
	move.w	#%1111111111111011,d6	; sous-marin ?
	rol.w	d4,d6
	or.w	d5,d6
	cmp.w	#$FFFF,d6
	bne	l1
	clr.w	d7
	bra	lfound
 l1:
	move.w	#%1111111111110111,d6	; destroyer1 ?
	rol.w	d4,d6
	or.w	d5,d6
	cmp.w	#$FFFF,d6
	bne	l2
	moveq	#1,d7
	bra	lfound
 l2:
	move.w	#%1111111111101111,d6	; destroyer2 ?
	rol.w	d4,d6
	or.w	d5,d6
	cmp.w	#$FFFF,d6
	bne	l3
	moveq	#2,d7
	bra	lfound
 l3:
	move.w	#%1111111111011111,d6	; frégate ?
	rol.w	d4,d6
	or.w	d5,d6
	cmp.w	#$FFFF,d6
	bne	l4
	moveq	#3,d7
	bra	lfound
 l4:
	moveq	#4,d7	; donc porte-avions
 lfound:
	move.l	a4,a0	; on charge l'adresse du tableau dans a0
	move.l	d7,d0	; on veut la d7-ème valeur
	lsl.l	#1,d0	; la liste contient des mots
	sub.w	#1,0(a0,d0)	; une case de moins
	tst.w	0(a0,d0)	; si le bateau n'a plus de case, il est coulé (!!!)
	bne	ncoule
	movem.l 	a0-a6/d0-d7,-(a7)
	move.w	a,a5
	move.w	b,a6
	move.w	c,d5
	moveq	#%00000100,d3
	rol.w	d7,d3
	rol.w	d4,d3
	not.w	d3	; masque
	moveq	#9,d6	; on scanne toute la matrice pour trouver les bateaux qui ont étés coulés
 tx0:
	moveq	#9,d7
 tx00:
	move.w	d6,a
	move.w	d7,b
	add.w	#1,a
	add.w	#1,b
	bsr	get
	move.w	d3,d0
	or.w	c,d0
	cmp.w	#$FFFF,d0
	bne	tx1
	move.w	a,d0	; met x dans d0
	sub.w	#1,d0
	lsl.w	#3,d0
	add.w	#24,d0	; obtient les coordonnées du sprite
	move.b	joueur,d2
	add.w	#110,d0	; choisit la grille en fonction du joueur
	tst.w	d2
	beq	ptstr0000
	sub.w	#110,d0	; choisit la grille en fonction du joueur
	cmp.b	#2,nbrjoueurs	; la suite fait partie de la gestion des tirs ordi
	beq	ptstr0000
	move.w	a,-(a7)
	move.w	b,-(a7)
	move.w	c,-(a7)
	movem.w	d0-d7,-(a7)
	move.w	#%0000001000000000,c	; empèche de tirer à coté d'un bateau coulé
		; car les bateaux ne peuvent pas se toucher
	sub.w	#1,a
	sub.w	#1,b
	move.w	a,d3
	move.w	b,d4
	moveq	#2,d6
 ptstr00001:		; j'adore mes noms de labels!
	moveq	#2,d7
 ptstr00002:
	move.w	d3,d0
	move.w	d4,d1
	add.w	d6,d0
	add.w	d7,d1
	move.w	d0,a
	move.w	d1,b
	bsr	put
	dbra	d7,ptstr00002
	dbra	d6,ptstr00001
	movem.w	(a7)+,d0-d7
	move.w	(a7)+,c
	move.w	(a7)+,b
	move.w	(a7)+,a
 ptstr0000:
	move.w	b,d1	; met y dans d1
	moveq	#10,d2
	sub.w	d1,d2
	move.w	d2,d1
	lsl.w	#3,d1
	add.w	#30,d1	; obtient les coordonnées du sprite
	move.l	gray4lib::plane1,a1
	lea	tir3c,a0
	jsr	graphlib::put_sprite
	move.l	gray4lib::plane0,a1
	jsr	graphlib::put_sprite
 tx1:
	dbra	d7,tx00
	dbra	d6,tx0
	move.w	a5,a
	move.w	a6,b
	movem.l 	(a7)+,a0-a6/d0-d7
	move.w	#4,-(a7)	; empile la couleur
	pea	coule(pc)	; empile le pointeur de la chaîne de caractère
	move.w	a6,-(a7)	; empile l'ordonnée
	move.w	#133,-(a7)	; empile l'abscisse
	jsr	tios::DrawStrXY	; appelle la fonction
	lea	10(a7),a7	; restaure la pile de 2+4+2+2=10
	tst.b	joueur
	beq	ncoule
	move.w	#1,cle
 ncoule:		; pas coulé, mais touché quand même...
	move.w	#4,-(a7)	; empile la couleur
	pea	touche(pc)	; empile le pointeur de la chaîne de caractère
	move.w	a6,-(a7)	; empile l'ordonnée
	move.w	#133,-(a7)	; empile l'abscisse
	jsr	tios::DrawStrXY	; appelle la fonction
	lea	10(a7),a7	; restaure la pile de 2+4+2+2=10
	tst.b	joueur
	beq	nc0
	move.w	#1,tch
 nc0:
	movem.l 	a0-a6/d0-d7,-(a7)
	moveq	#104,d0
	move.w	a6,d1
	sub.w	#1,d1
	move.w	#134,d2
	moveq	#8,d3
	clr.w	d4
	moveq	#79,d7
	move.l	gray4lib::plane0,a1	; séléctionne l'écran gris clair
	tst.b	joueur
	bne	txs1	; si le joueur 1 tire
	sub.w	#1,tot2
	bra	txs2
 txs1:
	sub.w	#1,tot1
 txs2:
	bsr	wait
	bsr	mtr
	dbra	d7,txs2
	movem.l 	(a7)+,a0-a6/d0-d7
 tirx1:
	move.w	#%0000000000000010,c	; valeurs pour empêcher de tirer 2 fois au même endroit
	tst.b	joueur
	beq	tirf1
	move.w	#%0000001000000000,c	; si le joueur 1 est actif
 tirf1:
	bsr	put
	moveq	#3,d7
 tirw:
	bsr	wait
	dbra	d7,tirw
	tst.b	joueur
	beq	cont	; les deux joueurs doivent tirer le même nombre de fois
		; on effectue donc les tests après le tir du joueur2
	move.w	tot1,d0
	add.w	tot2,d0
	tst.w	d0	; si tot1+tot2=0 alors tot1=tot2=0, tous les bateaux ont été coulés
	beq	egalite
	tst.w	tot1
	beq	j2gagne
	tst.w	tot2
	beq	j1gagne
	bra	cont
 egalite:
	lea	egal(pc),a3
	lea	old_int1,a4	; l'adresse de oldint1 est du type 00xxxxxx donc le premier octet est nul
	bra	jfin	; donc je l'utilise comme chaîne de caractère... vide!
 j1gagne:
	lea	gagnant(pc),a3
	lea	j1(pc),a4
	bra	jfin
 j2gagne:
	cmp.b	#2,nbrjoueurs
	bne	j2g2
	lea	gagnant(pc),a3
	lea	j2(pc),a4
	bra	jfin
 j2g2:
	lea	gagnant(pc),a3
	lea	ordi(pc),a4
 jfin:
	lea	rejouer(pc),a5
 ; box
 ; input:	a3.l	adresse du texte 1
 ;	a4.l	adresse du texte 2
 ;	a5.l	adresse du texte 2
	move.l	gray4lib::plane1,a1
	moveq	#62,d0
	moveq	#30,d1
	moveq	#113,d2
	moveq	#65,d3
	moveq	#2,d4
	bsr	mtr
	move.l	gray4lib::plane0,a1
	move.w	#1,d4
	bsr	mtr
	move.l	gray4lib::plane1,a1
	moveq	#63,d0
	moveq	#31,d1
	moveq	#111,d2
	moveq	#63,d3
	bsr	mtr
	move.l	gray4lib::plane0,a1
	bsr	mtr
	moveq	#64,d0
	moveq	#32,d1
	moveq	#109,d2
	moveq	#61,d3
	moveq	#2,d4
	bsr	mtr
	moveq	#69,d0
	moveq	#78,d1
	moveq	#44,d2
	moveq	#11,d3
	moveq	#1,d4
	bsr	mtr
	add.w	#55,d0
	bsr	mtr
	moveq	#125,d0
	moveq	#79,d1
	moveq	#42,d2
	moveq	#9,d3
	moveq	#2,d4
	bsr	mtr
	lea	tios::DrawStrXY,a6
	move.w	#4,-(a7)	; couleur
	move.l	a3,-(a7)	; texte1
	move.l	#$005F0027,-(a7)	; l'abscisse et ordonnée
	jsr	(a6)	; appelle la fonction
	move.w	#4,-(a7)
	move.l	a4,-(a7)	; texte2
	move.l	#$005F0031,-(a7)	; empile l'abscisse
	jsr	(a6)
	move.w	#4,-(a7)
	move.l	a5,-(a7)	; texte3
	move.l	#$00460050,-(a7)
	jsr	(a6)
	move.w	#4,-(a7)
	pea	quitter(pc)	; texte4
	move.l	#$007D0050,-(a7)
	jsr	(a6)
	lea	40(a7),a7	; restaure la pile de 2+4+2+2=10 4 fois
	clr.w	d6	; le curseur est sur [texte 3]
	moveq	#79,d1
	moveq	#42,d2
	moveq	#9,d3
	moveq	#2,d4
	clr.w	d4
 bx1:
 	move.l	gray4lib::plane0,a1
	moveq	#70,d0
	bsr	mtr
	add.w	#55,d0
	bsr	mtr
 bx0:
	bsr	getk
	cmp.w	#5,d0	; enter (ou lock)
	beq	bx2
	cmp.w	#1,d0	; gauche
	beq	bx4
	cmp.w	#2,d0	; droite
	beq	bx5
	bra	bx0
 bx2:
	tst.w	d6
	bne	fin2
	bsr	prepback
	move.l	save,a7	; je suis toujours sûr de ne pas planter au retour avec ça :o)
	bra	seawar	; là je saute au moins 2 rts, ça ne plante pas seulement parceque
		; j'ai restitué a7 tel qu'il était à l'origine, sinon c'est le crash assuré!
 bx4:
	tst.w	d6
	beq	bx0
	clr.w	d6
	bra	bx1
 bx5:
	cmp.w	#1,d6
	beq	bx0
	moveq	#1,d6
	bra	bx1
 cont:		; fin du tir joueur
	tst.b	joueur
	beq	tj00
	clr.b	joueur
	bra	tir1
 tj00:
	move.b	#1,joueur	; fait tirer l'ordinateur en mode 1 joueur et le joueur2 sinon
	cmp.b	#1,nbrjoueurs
	bne	tir1
	bsr	tirordi
	bra	tir1
 ;*************************** préparation du retour **************************
 fin2:
	bsr	prepback	; restaure les ints
	move.l	save,a7	; je suis toujours sûr de ne pas planter au retour avec ça :o)
	rts		; quitte le programme
 ;***************************** fin du programme *****************************
 newint1:		; nouveau vecteur int1
	rte		; équivalent de rts pour les ints
 ;****************************************************************************
 ;********************************* variables ********************************
 ; structure de la matrice:
 ;
 ;	xxxxxxxxxxxx b =
 ;	xwwwwwwwwwwx-10
 ;	xwwwwwwwwwwx-9
 ;	xwwwwwwwwwwx-8
 ;	xwwwwwwwwwwx-7
 ;	xwwwwwwwwwwx-6
 ;	xwwwwwwwwwwx-5
 ;	xwwwwwwwwwwx-4
 ;	xwwwwwwwwwwx-3
 ;	xwwwwwwwwwwx-2
 ;	xwwwwwwwwwwx-1
 ;	xxxxxxxxxxxx
 ;	 ||||||||||
 ;	   a = 12345678910
 ;
 ; les "w" sont des mots, les "x" sont inutilisés, ils servent de "marge de sécurité" pour ne pas
 ; aller lire des octets hors de la matrice qui pourraient fausser les test de placement
 ;
 ; structure d'un mot de la matrice:
 ;
 ; xxxxxxxx........ tout concernant le joueur 2
 ; ........xxxxxxxx pour le joueur 1
 ; 
 ; il y a donc un octet par joueur:
 ;
 ; .......x	présence d'un bateau du joueur
 ; ......x.	le joueur a tiré ici
 ; .....x..	le bateau est ...	sous marin
 ; ....x...		destroyer
 ; ...x....		destroyer
 ; ..x.....		frégate
 ; .x......		porte-avions
 ; x.......	(le bateau est touché) inutilisé car ......xx = bateau + tir = touché
 ; 76543210	le bateau est coulé si batj* vaut 0 au mot correspondant à ce bateau
longbat	dc.w	bat1,bat2,bat3,bat4,bat5	; liste de référence des longueurs des bateaux
rand_seed	dc.w	1	; pour générer des nombres pseudo-aléatoires
		; les autres variables sont dans le bss
 ;********************************** chaînes *********************************
_comment	dc.b	"Ximoon's Seawar 0.64",0
titre	dc.b	"SeaWar",0


	ifeq	langue

unjoueur	dc.b	"Partie à un joueur",0
deuxjoueurs	dc.b	"Partie à deux joueurs",0
chcase	dc.b	"Choisir une case",0
dernord	dc.b	"Dernier tir Ordi:",0
touche	dc.b	": touché",0
coule	dc.b	": touché-coulé!",0
dansleau	dc.b	": dans l'eau",0
gagnant	dc.b	"Gagnant:",0
egal	dc.b	"Egalité!",0
j1	dc.b	"Joueur 1",0
j2	dc.b	"Joueur 2",0
ordi	dc.b	"  Ordi",0
quitter	dc.b	"Quitter",0
rejouer	dc.b	"Rejouer",0
	endif

	ifeq	langue-1
unjoueur	dc.b	"    One player",0
deuxjoueurs	dc.b	"     Two players",0
chcase	dc.b	"Select",0
dernord	dc.b	"Last comp. shot:",0
touche	dc.b	": Hit",0
coule	dc.b	":Hit & destroyed!",0
dansleau	dc.b	": Missed",0
gagnant	dc.b	"Winner :",0
egal	dc.b	"Equality",0
j1	dc.b	"Player 1",0
j2	dc.b	"Player  2",0
ordi	dc.b	"  Comp. ",0
quitter	dc.b	" Exit",0
rejouer	dc.b	" Play",0
	endif


ca	dc.b	"ABCDEFGHIJ",0
tcor	dc.b	0,"-",0,0,0
 ;********************************** sprites *********************************
	even	; ça fait pas mal de sprites ça!
pvc 	dc.w 45	; sprites au format pour graphlib
	dc.w 2	; bateaux
 dc.b $1F,$C0	; xyz	hauteur.w en pixels
 dc.b $7C,$20	;	largeur.w en octets
 dc.b $42,$70	;	sprite
 dc.b $6B,$70	;	masque (pour les sprites de tir seulement)
 dc.b $63,$70
 dc.b $EB,$F0	; comment s'y retrouver?
 dc.b $9F,$10	; nom du sprite = xyz
 dc.b $DF,$70	; x:
 dc.b $FF,$50	; p = porte-avions
 dc.b $83,$78	; f = frégate
 dc.b $FF,$5C	; s = destroyer (avant c'était des sous-marins)
 dc.b $FF,$18	; n = sous-marin (avant c'était une navette)
 dc.b $7F,$70	;
 dc.b $41,$50	; y:
 dc.b $43,$78	; v = vertical
 dc.b $7B,$7C	; h = horizontal
 dc.b $3B,$78	;
 dc.b $2B,$F0	; z:
 dc.b $2B,$70	; c = clair
 dc.b $2B,$78	; f = foncé
 dc.b $2B,$F8
 dc.b $2F,$78	; les sprites prennent environ 1000 octets
 dc.b $37,$78	; mais c'est quand même plus joli qu'avant...
 dc.b $2B,$F8	; et le code est beaucoup plus propre :o)
 dc.b $5B,$78
 dc.b $6B,$78	; pour faire mes sprites, j'ai écrit mon propre logiciel
 dc.b $2F,$F8	; en Visual Basic 4.0, "Spriter" disponible sur mon site ;o)
 dc.b $37,$78
 dc.b $2B,$78
 dc.b $5B,$F8
 dc.b $7B,$78
 dc.b $7B,$78
 dc.b $5B,$F8
 dc.b $5B,$78
 dc.b $5B,$78
 dc.b $5B,$FC
 dc.b $7B,$74
 dc.b $5F,$74
 dc.b $5F,$F4
 dc.b $5F,$F4
 dc.b $4F,$F4
 dc.b $5F,$F4
 dc.b $5F,$84
 dc.b $5F,$FC
 dc.b $7F,$00
pvf 	dc.w 45
	dc.w 2
 dc.b $1F,$C0
 dc.b $7F,$E0
 dc.b $7F,$90
 dc.b $41,$90
 dc.b $41,$90
 dc.b $E1,$10
 dc.b $F1,$F0
 dc.b $B1,$F0
 dc.b $FE,$F0
 dc.b $FE,$E8
 dc.b $82,$B4
 dc.b $82,$F8
 dc.b $7E,$F0
 dc.b $7E,$F0
 dc.b $7C,$E8
 dc.b $74,$14
 dc.b $24,$18
 dc.b $34,$10
 dc.b $34,$10
 dc.b $34,$08
 dc.b $34,$08
 dc.b $3C,$08
 dc.b $3C,$08
 dc.b $3C,$08
 dc.b $74,$08
 dc.b $74,$08
 dc.b $3C,$08
 dc.b $3C,$08
 dc.b $3C,$08
 dc.b $74,$08
 dc.b $64,$08
 dc.b $44,$08
 dc.b $64,$08
 dc.b $64,$08
 dc.b $64,$08
 dc.b $74,$04
 dc.b $5C,$0C
 dc.b $60,$0C
 dc.b $70,$0C
 dc.b $78,$0C
 dc.b $70,$0C
 dc.b $70,$0C
 dc.b $78,$7C
 dc.b $60,$FC
 dc.b $7F,$00
fvc	dc.w 38
	dc.w 2
 dc.b $1F,$00
 dc.b $1F,$00
 dc.b $2F,$80
 dc.b $3C,$80
 dc.b $3E,$80
 dc.b $34,$80
 dc.b $33,$80
 dc.b $2F,$80
 dc.b $3F,$80
 dc.b $21,$80
 dc.b $3F,$80
 dc.b $3C,$C0
 dc.b $5F,$C0
 dc.b $7C,$C0
 dc.b $7F,$C0
 dc.b $78,$40
 dc.b $78,$40
 dc.b $5F,$80
 dc.b $5E,$80
 dc.b $3F,$80
 dc.b $27,$80
 dc.b $2E,$80
 dc.b $3D,$80
 dc.b $3B,$80
 dc.b $37,$80
 dc.b $3F,$C0
 dc.b $3F,$E0
 dc.b $37,$C0
 dc.b $3B,$80
 dc.b $3F,$80
 dc.b $7F,$80
 dc.b $FF,$80
 dc.b $7B,$80
 dc.b $3D,$80
 dc.b $3F,$80
 dc.b $39,$00
 dc.b $7E,$00
 dc.b $20,$00
fvf 	dc.w 38
	dc.w 2
 dc.b $1F,$00
 dc.b $11,$00
 dc.b $3F,$80
 dc.b $2B,$80
 dc.b $39,$80
 dc.b $2C,$80
 dc.b $2E,$80
 dc.b $22,$80
 dc.b $3F,$80
 dc.b $3E,$80
 dc.b $2F,$80
 dc.b $3F,$40
 dc.b $7F,$C0
 dc.b $50,$C0
 dc.b $5F,$C0
 dc.b $4F,$C0
 dc.b $78,$40
 dc.b $7F,$80
 dc.b $63,$80
 dc.b $3E,$80
 dc.b $38,$80
 dc.b $37,$80
 dc.b $2F,$80
 dc.b $2D,$80
 dc.b $2E,$80
 dc.b $21,$40
 dc.b $2C,$A0
 dc.b $3E,$C0
 dc.b $36,$80
 dc.b $2C,$80
 dc.b $50,$80
 dc.b $A6,$80
 dc.b $6F,$80
 dc.b $2B,$80
 dc.b $36,$80
 dc.b $2F,$00
 dc.b $5E,$00
 dc.b $20,$00
svc 	dc.w 27
	dc.w 2
 dc.b $1F,$00
 dc.b $22,$80
 dc.b $3F,$80
 dc.b $33,$80
 dc.b $7F,$80
 dc.b $52,$80
 dc.b $5F,$C0
 dc.b $51,$40
 dc.b $7F,$C0
 dc.b $6E,$80
 dc.b $3F,$80
 dc.b $3F,$80
 dc.b $3F,$80
 dc.b $31,$80
 dc.b $37,$80
 dc.b $33,$C0
 dc.b $3F,$E0
 dc.b $3F,$C0
 dc.b $3F,$80
 dc.b $3F,$80
 dc.b $31,$80
 dc.b $35,$80
 dc.b $3F,$80
 dc.b $7E,$80
 dc.b $39,$00
 dc.b $1A,$00
 dc.b $04,$00
svf 	dc.w 27
	dc.w 2
 dc.b $1F,$00
 dc.b $3F,$80
 dc.b $22,$80
 dc.b $22,$80
 dc.b $7F,$80
 dc.b $7C,$80
 dc.b $7F,$C0
 dc.b $7E,$40
 dc.b $5F,$C0
 dc.b $49,$80
 dc.b $38,$80
 dc.b $20,$80
 dc.b $2E,$80

 dc.b $39,$80
 dc.b $39,$80
 dc.b $3D,$40
 dc.b $2E,$A0
 dc.b $21,$40
 dc.b $20,$80
 dc.b $2E,$80
 dc.b $3D,$80
 dc.b $39,$80
 dc.b $29,$80
 dc.b $57,$80
 dc.b $2F,$00
 dc.b $1E,$00
 dc.b $04,$00
nvc 	dc.w 18
	dc.w 2
 dc.b $08,$00
 dc.b $14,$00
 dc.b $14,$00
 dc.b $14,$00
 dc.b $26,$00
 dc.b $26,$00
 dc.b $26,$00
 dc.b $26,$00
 dc.b $4B,$00
 dc.b $5F,$00
 dc.b $FF,$80
 dc.b $DC,$80
 dc.b $77,$00
 dc.b $55,$00
 dc.b $2A,$00
 dc.b $22,$00
 dc.b $14,$00
 dc.b $08,$00
nvf 	dc.w 18
	dc.w 2
 dc.b $08,$00
 dc.b $14,$00
 dc.b $14,$00
 dc.b $14,$00
 dc.b $32,$00
 dc.b $32,$00
 dc.b $32,$00
 dc.b $32,$00
 dc.b $61,$00
 dc.b $7D,$00
 dc.b $F7,$80
 dc.b $B6,$80
 dc.b $77,$00
 dc.b $77,$00
 dc.b $3E,$00
 dc.b $3A,$00
 dc.b $14,$00
 dc.b $08,$00
phc 	dc.w 14
	dc.w 6
 dc.b $00,$21,$00,$00,$1F,$F0
 dc.b $00,$73,$9F,$FF,$F0,$10
 dc.b $3F,$FF,$FF,$FF,$FF,$D0
 dc.b $7D,$4B,$FF,$FF,$FF,$D0
 dc.b $BD,$EF,$FF,$FF,$FF,$D0
 dc.b $84,$00,$49,$24,$93,$F0
 dc.b $9F,$FF,$FF,$FF,$FF,$F8
 dc.b $BF,$FB,$FF,$FF,$FF,$F8
 dc.b $C3,$B8,$06,$30,$07,$F8
 dc.b $D7,$B9,$FD,$EF,$FF,$F8
 dc.b $C3,$B9,$82,$97,$FF,$78
 dc.b $5C,$B9,$FF,$7B,$08,$08
 dc.b $7D,$BF,$00,$C7,$FF,$F8
 dc.b $07,$F0,$00,$00,$00,$00
phf 	dc.w 14
	dc.w 6
 dc.b $00,$21,$00,$00,$1F,$F0
 dc.b $00,$52,$9F,$FF,$EF,$F0
 dc.b $3F,$BD,$E0,$00,$00,$30
 dc.b $43,$FE,$00,$00,$00,$30
 dc.b $C3,$DE,$00,$00,$00,$30
 dc.b $FB,$FE,$00,$00,$00,$10
 dc.b $FF,$00,$00,$00,$00,$08
 dc.b $E0,$FC,$00,$00,$00,$08
 dc.b $E0,$CF,$FF,$FF,$F8,$08
 dc.b $E0,$CE,$07,$38,$09,$28
 dc.b $E3,$CF,$7F,$FC,$1B,$E8
 dc.b $67,$CF,$FF,$FE,$F7,$F8
 dc.b $7E,$CF,$00,$C7,$FF,$F8
 dc.b $07,$F0,$00,$00,$00,$00
fhc 	dc.w 11
	dc.w 5
 dc.b $00,$00,$00,$20,$00
 dc.b $00,$1F,$80,$70,$00
 dc.b $3F,$FE,$7F,$FF,$E0
 dc.b $E3,$EA,$5B,$FF,$F0
 dc.b $EB,$AA,$7D,$FF,$A8
 dc.b $FD,$BE,$7E,$F7,$68
 dc.b $F9,$BF,$F7,$6F,$F8
 dc.b $DE,$BF,$F3,$FF,$F8
 dc.b $3F,$F7,$9F,$FF,$FC
 dc.b $00,$0F,$E0,$03,$88
 dc.b $00,$00,$00,$01,$00
	even
fhf 	dc.w 11
	dc.w 5
 dc.b $00,$00,$00,$20,$00
 dc.b $00,$1F,$80,$50,$00
 dc.b $3F,$EF,$7F,$BF,$E0
 dc.b $F8,$BB,$67,$40,$D0
 dc.b $B3,$FB,$76,$99,$F8
 dc.b $A6,$FB,$57,$BD,$B8
 dc.b $BE,$FB,$DB,$B4,$D8
 dc.b $E8,$DE,$DC,$1A,$28
 dc.b $3F,$F8,$FF,$FD,$F4
 dc.b $00,$0F,$E0,$02,$88
 dc.b $00,$00,$00,$01,$00
	even
shc 	dc.w 10
	dc.w 4
 dc.b $00,$00,$80,$00
 dc.b $03,$81,$C0,$00
 dc.b $7E,$FF,$FF,$00
 dc.b $BB,$BF,$FE,$80
 dc.b $FE,$FB,$F3,$40
 dc.b $AA,$FA,$F7,$20
 dc.b $AA,$F8,$F3,$C0
 dc.b $BF,$BF,$FF,$C0
 dc.b $78,$FF,$FF,$80
 dc.b $0F,$C0,$01,$00
shf 	dc.w 10
	dc.w 4
 dc.b $00,$00,$80,$00
 dc.b $03,$81,$40,$00
 dc.b $7E,$FE,$BF,$00
 dc.b $CA,$C7,$4F,$80
 dc.b $FB,$88,$91,$C0
 dc.b $CF,$89,$99,$E0
 dc.b $CF,$EF,$9E,$C0
 dc.b $CF,$A7,$0D,$40
 dc.b $7F,$3F,$FE,$80
 dc.b $0F,$C0,$01,$00
nhc 	dc.w 9
	dc.w 3
 dc.b $00,$30,$00
 dc.b $00,$EC,$00
 dc.b $0F,$EB,$00
 dc.b $7F,$7C,$80
 dc.b $80,$F2,$40
 dc.b $70,$7C,$80
 dc.b $0F,$2B,$00
 dc.b $00,$FC,$00
 dc.b $00,$30,$00
	even
nhf	dc.w 9
	dc.w 3
 dc.b $00,$30,$00
 dc.b $00,$EC,$00
 dc.b $0F,$3F,$00
 dc.b $70,$7E,$80
 dc.b $80,$43,$40
 dc.b $7F,$7F,$80
 dc.b $0F,$FF,$00
 dc.b $00,$EC,$00
 dc.b $00,$30,$00
	even
tirc	dc.w 7		; sprites du tir
	dc.w 1
 dc.b $BA
 dc.b $54
 dc.b $82
 dc.b $C6
 dc.b $82
 dc.b $54
 dc.b $BA
 dc.b $FE
 dc.b $FE
 dc.b $FE
 dc.b $FE
 dc.b $FE
 dc.b $FE
 dc.b $FE
	even
tirf	dc.w 7
	dc.w 1
 dc.b $7C
 dc.b $EE
 dc.b $C6
 dc.b $82
 dc.b $C6
 dc.b $EE
 dc.b $7C
 dc.b $FE
 dc.b $FE
 dc.b $FE
 dc.b $FE
 dc.b $FE
 dc.b $FE
 dc.b $FE
tir2c	dc.w 5
	dc.w 1
 dc.b $00
 dc.b $00
 dc.b $28
 dc.b $10
 dc.b $28
 dc.b $00
 dc.b $00
 dc.b $38
 dc.b $38
 dc.b $38
	even
tir2f	dc.w 5
	dc.w 1
 dc.b $00
 dc.b $00
 dc.b $10
 dc.b $38
 dc.b $10
 dc.b $00
 dc.b $00
 dc.b $38
 dc.b $38
 dc.b $38
tir3c	dc.w 5
	dc.w 1
 dc.b $00
 dc.b $00
 dc.b $38
 dc.b $38
 dc.b $38
 dc.b $00
 dc.b $00
 dc.b $38
 dc.b $38
 dc.b $38
 ;****************************************************************************
	bss		; tout celà est créé vide au moment de l'éxécution
	even		; plus de 350 octets économisés :o)
matrice	ds.w	144	; matrice de 10*10 contenant des mots + bords de sécurité=12*12
old_int1	dc.l	0	; sauvegarde de l'int1 avant son détournement
save	dc.l	0	; sauvegarde de a7 au début du programme pour le restaurer inchangé au retour
u1	dc.l	0	; sauvegarde des cases choisies avec selec pour chaque joueur
cp	dc.l	0	; chaîne de caractères
batj1	ds.w	5	; liste du nombre de cases intactes pour chaque bateau du joueur 1
batj2	ds.w	5	; liste du nombre de cases intactes pour chaque bateau du joueur 2
tot1	dc.w	0	; nombre total de cases non touchées du joueur 1
tot2	dc.w	0	; nombre total de cases non touchées du joueur 2
c	dc.w	0	; valeur mise/lue à (a,b) dans la matrice
a	dc.w	0	; coordonnées matrice
b	dc.w	0	; "
x	dc.w	0	; coordonées tir ordinateur
y	dc.w	0	; "
xr	dc.w	0	; coordonnées de la première case touchée par l'ordinateur
yr	dc.w	0	; "
rtir	dc.w	0	; étape du tir ordinateur 0, 1 ou 2
tircte	dc.w	0	; constante pour quadrier le tir 0 ou 1
tch	dc.w	0	; 1 si touché
cle	dc.w	0	; 1 si coulé
vdpl	dc.b	0	; déplacement vertical pour selec
hdpl	dc.b	0	; déplacement horizontal pour sélec
KbdMat	ds.b 10	; ExtendeD's "virtual keyboard"
joueur	dc.b	0	; joueur actif (0 =j2 ou ordi, 1 =j1)
nbrjoueurs	dc.b	0	; nombre de joueurs 1 ou 2
sens	dc.b	0	; 0 = horizontal 1 = vertical
erreur	dc.b	0	; erreur=1,0 sinon
ancd0	dc.b	0	; une sauvegarde de d0 dans getk
sel	dc.b	0	; détermine si getkey a été appelé par selec ou non
 ;****************************************************************************
	end