WebSVN – Kolibri OS – Diff – /programs/games/c4/trunk/c4.asm


; C4
; Copyright (c) 2002 Thomas Mathys
; killer@vantage.ch
;
; This file is part of C4.
;
; C4 is free software; you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by
; the Free Software Foundation; either version 2 of the License, or
; (at your option) any later version.
;
; C4 is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
; GNU General Public License for more details.
;
; You should have received a copy of the GNU General Public License
; along with C4; if not, write to the Free Software
; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
	bits 32
	%include 'mos.inc'
	section .text
	%include 'lang_nasm.inc' ;fedesco
 
 
	MOS_HEADER01 start,end
 
 
 
;**********************************************************
; magic numbers
;**********************************************************
 
; initial player types
PL1TYPE_INIT		equ	0
PL2TYPE_INIT		equ	4
 
; window
WND_WIDTH		equ	259
WND_HEIGHT		equ	300
WND_WORKCOLOR		equ	0
 
; button dimensions
BUTTON_HEIGHT		equ	12
 
BUTTON_NEW_X		equ	14
BUTTON_NEW_Y		equ	30
%ifidn lang, 'it'
	BUTTON_NEW_WIDTH equ 56 + 28
%else
	BUTTON_NEW_WIDTH equ 56
%endif
 
BUTTON_SPIN_WIDTH	equ	8
BUTTON_PL1DN_X		equ	228
BUTTON_PL1DN_Y		equ	30
BUTTON_PL1UP_X		equ	(BUTTON_PL1DN_X + BUTTON_SPIN_WIDTH + 1)
BUTTON_PL1UP_Y		equ	BUTTON_PL1DN_Y
 
BUTTON_PL2DN_X		equ	BUTTON_PL1DN_X
BUTTON_PL2DN_Y		equ	(BUTTON_PL1DN_Y + 20)
BUTTON_PL2UP_X		equ	(BUTTON_PL2DN_X + BUTTON_SPIN_WIDTH + 1)
BUTTON_PL2UP_Y		equ	BUTTON_PL2DN_Y
 
; label dimensions
%ifidn lang, 'it'
	LABEL_PL1_X      equ   90 + 10
%else
	LABEL_PL1_X      equ   90
%endif
LABEL_PL1_Y		equ	(1 + BUTTON_PL1DN_Y + (BUTTON_HEIGHT-8)/2)
LABEL_PL2_X		equ	LABEL_PL1_X
LABEL_PL2_Y		equ	(1 + BUTTON_PL2DN_Y + (BUTTON_HEIGHT-8)/2)
%ifidn lang, 'it'
        LABEL_PL1TYPE_X      equ   (LABEL_PL1_X + 10*6 - 4)
%else
        LABEL_PL1TYPE_X      equ   (LABEL_PL1_X + 10*6)
%endif
LABEL_PL1TYPE_Y		equ	LABEL_PL1_Y
LABEL_PL2TYPE_X		equ	LABEL_PL1TYPE_X
LABEL_PL2TYPE_Y		equ	LABEL_PL2_Y
LABEL_STATUS_X		equ	14
LABEL_STATUS_Y		equ	279
LABEL_STATUS_WIDTH	equ	220
LABEL_STATUS_HEIGHT	equ	12
 
 
 
; board and stones
STONESIZE		equ	32			; stone height and width
GRIDX			equ	14			; upper left corner
GRIDY			equ	70
GRIDSPACING		equ	(STONESIZE + 1)		; space between lines
GRIDHEIGHT		equ	(6*GRIDSPACING+1)	; total grid width and height
GRIDWIDTH		equ	(7*GRIDSPACING+1)
GRIDCOLOR		equ	MOS_RGB(128,128,128)
 
 
 
; button id's
BT_QUIT			equ	1
BT_NEW			equ	2
BT_PLAYER1DN		equ	3
BT_PLAYER1UP		equ	4
BT_PLAYER2DN		equ	5
BT_PLAYER2UP		equ	6
 
 
start:
	jmp main
 
%include "pcx.inc"
%include "windows.inc"
%include "board.inc"
%include "rng.inc"
; %include "randomai.inc"
%include "ai.inc"
 
 
 
;**********************************************************
; main program
;**********************************************************
main:
	call randomize
	call defineWindow
	call decrunchImages
	call newGame
 
.msgpump:
	; wait for event
	mov ebx,1
	mov eax,MOS_SC_WAITEVENTTIMEOUT
	int 0x40
 
	; process events
	cmp eax,MOS_EVT_REDRAW
	je short .redraw
	cmp eax,MOS_EVT_KEY
	je short .key
	cmp eax,MOS_EVT_BUTTON
	je short .button
 
	call pollMouse
	call gameLoop
	jmp short .msgpump
 
.redraw:
	call defineWindow
	jmp short .msgpump
.key:
	call keyboardInput
	jmp short .msgpump
.button:
	call handleButton
	jmp short .msgpump
 
 
 
;**********************************************************
; button handling function
;**********************************************************
handleButton:
	mov eax,MOS_SC_GETPRESSEDBUTTON		; get button id
	int 0x40
 
	cmp al,1				; button pressed ?
	je short .bye				; nope -> nothing to do
 
	cmp ah,BT_QUIT				; which button has been pressed ?
	je short .quit
	cmp ah,BT_NEW
	je short .new
	cmp ah,BT_PLAYER1DN
	je short .player1dn
	cmp ah,BT_PLAYER1UP
	je short .player1up
	cmp ah,BT_PLAYER2DN
	je short .player2dn
	cmp ah,BT_PLAYER2UP
	je short .player2up
.bye:
	ret
.quit:
	MOS_EXIT
.new:
	call newGame
	ret
.player1dn:
	mov eax,[player1_type]		; get current type
	or eax,eax			; already zero ?
	jz .bla
	dec eax				; nope -> decrement
	mov [player1_type],eax		; write back
	mov edi,label_pl1type		; and update label
	call updatePlayerType
.bla:
	ret
.player1up:
	mov eax,[player1_type]		; get current type
	cmp eax,NPLAYERTYPES-1		; already max ?
	je .bla2
	inc eax				; nope -> increment
	mov [player1_type],eax		; write back
	mov edi,label_pl1type		; update label
	call updatePlayerType
.bla2:
	ret
.player2dn:
	mov eax,[player2_type]		; get current type
	or eax,eax			; already zero ?
	jz .bla3
	dec eax				; nope -> decrement
	mov [player2_type],eax		; write back
	mov edi,label_pl2type		; and update label
	call updatePlayerType
.bla3:
	ret
.player2up:
	mov eax,[player2_type]
	cmp eax,NPLAYERTYPES-1
	je .bla4
	inc eax
	mov [player2_type],eax
	mov edi,label_pl2type
	call updatePlayerType
.bla4:
	ret
 
 
 
;**********************************************************
; window definition function
;**********************************************************
defineWindow:
	MOS_STARTREDRAW
 
	mov edi,window
	call drawWindow
 
	mov edi,buttons
	mov ecx,NBUTTONS
	call drawButtons
 
	mov edi,labels
	mov ecx,NLABELS
	call drawLabels
 
	xor eax,eax
	call drawBoard
 
	MOS_ENDREDRAW
	ret
 
 
 
;**********************************************************
; updateStatusText
;
; input		:	esi = ptr to new string
; output	:	status bar is updated
; destroys	:	everything
;**********************************************************
updateStatusText:
 
	; different text ?
	cmp [statusbar + LABEL.caption],esi
	je .bye							; nope -> bye
	mov dword [statusbar + LABEL.caption],esi		; yeah -> save & redraw
 
	; clear background
     	mov ebx,MOS_DWORD(LABEL_STATUS_X,LABEL_STATUS_WIDTH)
     	mov ecx,MOS_DWORD(LABEL_STATUS_Y,LABEL_STATUS_HEIGHT)
     	xor edx,edx
     	mov eax,MOS_SC_DRAWBAR
     	int 0x40
 
     	; redraw label
	mov edi,statusbar
	mov ecx,1
	call drawLabels
.bye:
	ret
 
 
 
;**********************************************************
; updatePlayerType
; update player type label
; input:	eax = new type
;		edi = address label structure to update
;**********************************************************
updatePlayerType:
	mov ebx,PLAYERTYPELEN				; calculate type string address
	mul ebx
	add eax,playertypes
	mov [edi + LABEL.caption],eax			; write address
	mov ecx,1					; and redraw label
	call drawLabels
	ret
 
 
 
;**********************************************************
; board drawing stuff
;**********************************************************
 
; drawBoard
; draw whole board
;
; input		:	eax nonzero = clear board background
drawBoard:
 
	; clear background ?
	or eax,eax
	jz .noclear
	mov ebx,MOS_DWORD(GRIDX,GRIDWIDTH)
	mov ecx,MOS_DWORD(GRIDY,GRIDHEIGHT)
	mov edx,WND_WORKCOLOR
	mov eax,MOS_SC_DRAWBAR
	int 0x40
.noclear:
	call drawGrid
	call drawStones
	ret
 
 
 
drawGrid:
 
	; vertical lines
	mov ebx,MOS_DWORD(GRIDX,GRIDX)
	mov ecx,MOS_DWORD(GRIDY,GRIDY+GRIDHEIGHT-1)
	mov edx,GRIDCOLOR
	mov eax,MOS_SC_DRAWLINE
	mov esi,8
.vlines:
	int 0x40
	add ebx,MOS_DWORD(GRIDSPACING,GRIDSPACING)
	dec esi
	jnz .vlines
 
	; horizontal lines
	mov ebx,MOS_DWORD(GRIDX,GRIDX+GRIDWIDTH-1)
	mov ecx,MOS_DWORD(GRIDY,GRIDY)
	mov esi,7
.hlines:
	int 0x40
	add ecx,MOS_DWORD(GRIDSPACING,GRIDSPACING)
	dec esi
	jnz .hlines
 
	ret
 
 
drawStones:
	mov ebx,6
.col:
	mov ecx,7
.row:
	call drawStone
	loop .row
	dec ebx
	jnz .col
	ret
 
 
 
; ecx = column (1..7)
; ebx = row (1..6)
drawStone:
	pushad
 
	; see which image to draw.
	; the image offset is stored in ebp
	mov eax,BWIDTH			; calculate address
	mul ebx
	add eax,ecx
	mov eax,[board+eax*4]		; get stone ?
	cmp eax,EMPTY			; empty field -> nothing to do
	je .bye
	mov ebp,redstone		; assume red stone
	cmp eax,PLAYER1			; red ?
	je .stoneok			; yeah -> continue
	mov ebp,bluestone		; nope -> use blue stone
.stoneok:
 
	; calculate image position (edx)
	mov eax,GRIDSPACING
	dec ecx
	mul ecx
	add eax,GRIDX + 1
	shl eax,16
	mov ecx,eax
	mov eax,GRIDSPACING
	dec ebx
	mul ebx
	add eax,GRIDY + 1
	mov cx,ax
	mov edx,ecx
 
	; put image (position is already in edx)
	mov ebx,ebp				; image address
	mov ecx,MOS_DWORD(STONESIZE,STONESIZE)	; image dimensions
	mov eax,MOS_SC_PUTIMAGE
	int 0x40
 
.bye:
	popad
	ret
 
 
 
decrunchImages:
	mov esi,redpcx			; red stone
	mov edi,redstone
	mov ebx,REDPCXSIZE
	call loadPCX
	mov esi,bluepcx			; blue stone
	mov edi,bluestone
	mov ebx,BLUEPCXSIZE
	call loadPCX
	ret
 
 
 
resetInput:
	mov dword [playerinput],0	; no player input
	mov dword [mouseinput],0
	ret
 
 
 
;**********************************************************
; newGame
; set up everything for a game
;
; input		:	nothing
; output	:	nothing
; destroys	:	everything
;**********************************************************
newGame:
	call boardReset			; reset and redraw board
	mov eax,1
	call drawBoard
	call resetInput			; reset input
	mov dword [gameover],0		; game is running
	ret
 
 
 
;**********************************************************
; pollMouse
; mouse polling routine
;
; input		:	nothing
; output	:	playerinput will be updated, if
;			the player clicked on a valid
;			field
; destroys	:	everything
;**********************************************************
pollMouse:
	mov ebx,2
	mov eax,MOS_SC_GETMOUSEPOSITION
	int 0x40
	and eax,1
	jz .mousenotpressed
.mousepressed:
	mov dword [mouseinput],0
	call isActiveApp
	or al,al
	jz .notactive1
	call getMouseCol
	mov [mouseinput],eax
.notactive1:
	ret
.mousenotpressed:
	call isActiveApp
	or al,al
	jz .notactive2
	call getMouseCol
	cmp eax,[mouseinput]
	jne .nonewinput
	cmp dword [playerinput],0
	jne .nonewinput
	mov [playerinput],eax
.nonewinput:
.notactive2:
	mov dword [mouseinput],0
	ret
 
 
 
;**********************************************************
; getMouseCol
; calculate in which column the mouse is. or so.
;
; input		:	nothing
; output	:	eax = 0 -> mouse outside board
;			eax = 1..7 -> column
; destroys	:	everything
;**********************************************************
getMouseCol:
 
	mov ebx,1			; get mouse position, window relative
	mov eax,MOS_SC_GETMOUSEPOSITION
	int 0x40
 
	movzx ebx,ax			; y clipping
	cmp ebx,GRIDY
	jl .outside
	cmp ebx,GRIDY + GRIDHEIGHT - 1
	jg .outside
 
	shr eax,16			; calculate column from x coordinate
	sub eax,GRIDX
	js .outside			; negative -> outside of board (left)
	cdq				; !
	mov ebx,GRIDSPACING
	div ebx
	cmp eax,BWIDTH-3		; right outside of board ?
	jg .outside			; yes -> bye
 
	inc eax				; xform into range [1,7]
	ret
.outside:
	xor eax,eax
	ret
 
 
 
;**********************************************************
; isActiveApp
; check wether we're the active application
;
; input		:	nothing
; output	:	al nonzero -> we are the active app
; destroys	:	everything
;**********************************************************
isActiveApp:
 
%define	PROCINFO (ebp-MOS_PROCESSINFO_size)
 
	enter MOS_PROCESSINFO_size,0
 
	; get process information
	mov eax,MOS_SC_GETPROCESSINFO
	lea ebx,[ebp-MOS_PROCESSINFO_size]
	mov ecx,-1
	int 0x40
 
	; set al to 1 if we are the active application
	cmp ax,[PROCINFO+MOS_PROCESSINFO.windowStackPos]
	sete al
 
	leave
	ret
%undef PROCINFO
 
 
 
;**********************************************************
; keyboardInput
; keyboard input handler, called from main loop
;
; input		:	nothing
; output	:	playerinput is updated
; destroys	:	everything
;**********************************************************
keyboardInput:
	mov eax,MOS_SC_GETKEY		; get key
	int 0x40
	or al,al			; key available ?
	jnz .bye			; no -> bye
	cmp dword [playerinput],0	; unprocessed input available ?
	jne .bye			; yes -> bye
 
	sub ah,'1'			; valid key ?
	cmp ah,BWIDTH-3
	ja .bye				; treat as unsigned : keys below '1' will
					; be greater too =)
 
	mov al,ah			; save input
	and eax,255
	inc eax
	mov [playerinput],eax
 
.bye:
	ret
 
 
 
;**********************************************************
; gameLoop
; game logic code or however you wish to call it.
; actually this is not a loop, but is called from
; the main loop
;**********************************************************
gameLoop:
 
	; if the game is over, return
	cmp dword [gameover],0
	je .gamerunning
	ret
.gamerunning:
 
	call updatePlayerStatusText
 
	; get move
	call getMoveForCurrentPlayer
	or eax,eax
	jnz .moveok
	ret			; no move available -> bye
.moveok:
 
	; make move and update board graphics
	mov ebx,[currentplayer]	; ebx = current player, eax contains already move
	call boardMakeMove
	call drawStones
 
	; check wether game is over (either by a win or because the board is full)
	mov eax,[currentplayer]			; win for current player ?
	call boardIsWin
	or eax,eax
	jz .nowin				; no -> continue
	mov esi,player1wins			; yes -> display message...
	cmp dword [currentplayer],PLAYER1
	je .blubb
	mov esi,player2wins
.blubb:
	call updateStatusText
	mov dword [gameover],1			; ...and end game
	ret
.nowin:
	BOARDISFULL				; board full, but no win ?
	jnz .notfull				; no -> continue
	mov esi,itisadraw			; yes -> display message...
	call updateStatusText
	mov dword [gameover],1			; ...and end game
	ret
.notfull:
 
	; switch players and return to main loop
	BOARDSWITCHPLAYERS
	ret
 
 
 
;**********************************************************
; getMoveForCurrentPlayer
; returns the move made by the current player
; (either cpu or human)
;
; input		:	nothing
; output	:	eax = 0 -> no move made. this is
;			usually the case for human players,
;			when no valid input is available.
;			else eax = move number
;**********************************************************
getMoveForCurrentPlayer:
 
	; get type of current player
	mov eax,[player1_type]
	cmp dword [currentplayer],PLAYER1
	je .ok
	mov eax,[player2_type]
.ok:
 
	; get move for human/cpu player
	or eax,eax
	jnz .cpu
.human:
	mov eax,[playerinput]	; get input
	or eax,eax		; input available ?
	jz .nomove		; no -> return no move available
	call resetInput		; !
	BOARDISVALIDMOVE eax	; valid move `?
	jz .nomove		; no -> return no move available
	ret			; valid move available -> return it (eax)
 
.cpu:
	call dword [aicode]	; call ai machine. cpu level is already in eax
	ret
.nomove:
	xor eax,eax
	ret
 
 
 
;**********************************************************
; update status bar : which player's turn it is
;**********************************************************
updatePlayerStatusText:
	cmp dword [currentplayer],PLAYER2
	je .player2
	mov esi,player1hmnprmpt
	cmp dword [player1_type],0
	je .statustextok
	mov esi,player1cpuprmpt
	jmp short .statustextok
.player2:
	mov esi,player2hmnprmpt
	cmp dword [player2_type],0
	je .statustextok
	mov esi,player2cpuprmpt
.statustextok:
	call updateStatusText
	ret
 
 
 
;**********************************************************
; initialized data
;**********************************************************
 
	section .data
 
;
; window definition
;
windowtitle	db	"C4 0.1",0
window:
istruc WND
	at WND.xposandsize,	dd	MOS_DWORD(0,WND_WIDTH)
	at WND.yposandsize,	dd	MOS_DWORD(0,WND_HEIGHT)
	at WND.workcolor,	dd	0x03000000 | WND_WORKCOLOR
	at WND.grabcolor,	dd	0
	at WND.framecolor,	dd	0
	at WND.caption,		dd	windowtitle
	at WND.captioncolor,	dd	0
	at WND.flags,		dd	WND_CENTER | WND_DEFAULT_GRABCOLOR | WND_DEFAULT_FRAMECOLOR | WND_DEFAULT_CAPTIONCOLOR
iend
 
;
; button table
;
buttons:
istruc BUTTON						; new
	at BUTTON.xposandsize
	dd MOS_DWORD(BUTTON_NEW_X,BUTTON_NEW_WIDTH)
	dd MOS_DWORD(BUTTON_NEW_Y,BUTTON_HEIGHT)
	dd BT_NEW
	dd BUTTON_COLOR_WORK
iend
istruc BUTTON						; player 1 down
	at BUTTON.xposandsize
	dd MOS_DWORD(BUTTON_PL1DN_X,BUTTON_SPIN_WIDTH)
	dd MOS_DWORD(BUTTON_PL1DN_Y,BUTTON_HEIGHT)
	dd BT_PLAYER1DN
	dd BUTTON_COLOR_WORK
iend
istruc BUTTON						; player 1 up
	at BUTTON.xposandsize
	dd MOS_DWORD(BUTTON_PL1UP_X,BUTTON_SPIN_WIDTH)
	dd MOS_DWORD(BUTTON_PL1UP_Y,BUTTON_HEIGHT)
	dd BT_PLAYER1UP
	dd BUTTON_COLOR_WORK
iend
istruc BUTTON						; player 2 down
	at BUTTON.xposandsize
	dd MOS_DWORD(BUTTON_PL2DN_X,BUTTON_SPIN_WIDTH)
	dd MOS_DWORD(BUTTON_PL2DN_Y,BUTTON_HEIGHT)
	dd BT_PLAYER2DN
	dd BUTTON_COLOR_WORK
iend
istruc BUTTON						; player 2 up
	at BUTTON.xposandsize
	dd MOS_DWORD(BUTTON_PL2UP_X,BUTTON_SPIN_WIDTH)
	dd MOS_DWORD(BUTTON_PL2UP_Y,BUTTON_HEIGHT)
	dd BT_PLAYER2UP
	dd BUTTON_COLOR_WORK
iend
NBUTTONS	equ	(($-buttons)/BUTTON_size)
 
 
;
; label table
;
%ifidn lang, 'it'
       newgame db   "Nuova partita",0
%else
       newgame db   "New game",0
%endif
down		db	"<",0
up		db	">",0
%ifidn lang, 'it'
       pl1		db	"Giocatore 1:",0
       pl2		db	"Giocatore 2:",0
%else
       pl1		db	"Player 1:",0
       pl2		db	"Player 2:",0
%endif
 
%ifidn lang, 'it'
	playertypes:
			db	"Umano",0
	PLAYERTYPELEN	equ	($ - playertypes)
			db	"CPU 1 ",0
			db	"CPU 2 ",0
			db	"CPU 3 ",0
			db	"CPU 4 ",0
			db	"CPU 5 ",0
			db	"CPU 6 ",0
			db	"CPU 7 ",0
			db	"CPU 8 ",0
%else
	playertypes:
			db	"Human       ",0
	PLAYERTYPELEN	equ	($ - playertypes)
			db	"CPU level 1 ",0
			db	"CPU level 2 ",0
			db	"CPU level 3 ",0
			db	"CPU level 4 ",0
			db	"CPU level 5 ",0
			db	"CPU level 6 ",0
			db	"CPU level 7 ",0
			db	"CPU level 8 ",0
%endif
 
NPLAYERTYPES	equ	(($-playertypes)/PLAYERTYPELEN)
 
 
labels:
istruc LABEL						; new
	at LABEL.position
	dd MOS_DWORD(BUTTON_NEW_X+4,1+BUTTON_NEW_Y+(BUTTON_HEIGHT-8)/2)
	dd newgame
	dd LABEL_COLOR_WORKBUTTON
	dd LABEL_BGCOLOR_TRANSPARENT
iend
istruc LABEL						; player 1 down
	at LABEL.position
	dd MOS_DWORD(BUTTON_PL1DN_X+(BUTTON_SPIN_WIDTH-4)/2,1+BUTTON_PL1DN_Y+(BUTTON_HEIGHT-8)/2)
	dd down
	dd LABEL_COLOR_WORKBUTTON
	dd LABEL_BGCOLOR_TRANSPARENT
iend
istruc LABEL						; player 1 up
	at LABEL.position
	dd MOS_DWORD(1+BUTTON_PL1UP_X+(BUTTON_SPIN_WIDTH-4)/2,1+BUTTON_PL1UP_Y+(BUTTON_HEIGHT-8)/2)
	dd up
	dd LABEL_COLOR_WORKBUTTON
	dd LABEL_BGCOLOR_TRANSPARENT
iend
istruc LABEL						; player 2 down
	at LABEL.position
	dd MOS_DWORD(BUTTON_PL2DN_X+(BUTTON_SPIN_WIDTH-4)/2,1+BUTTON_PL2DN_Y+(BUTTON_HEIGHT-8)/2)
	dd down
	dd LABEL_COLOR_WORKBUTTON
	dd LABEL_BGCOLOR_TRANSPARENT
iend
istruc LABEL						; player 2 up
	at LABEL.position
	dd MOS_DWORD(1+BUTTON_PL2UP_X+(BUTTON_SPIN_WIDTH-4)/2,1+BUTTON_PL2UP_Y+(BUTTON_HEIGHT-8)/2)
	dd up
	dd LABEL_COLOR_WORKBUTTON
	dd LABEL_BGCOLOR_TRANSPARENT
iend
istruc LABEL						; player 1
	at LABEL.position
	dd MOS_DWORD(LABEL_PL1_X,LABEL_PL1_Y)
	dd pl1
	dd MOS_RGB(255,255,255)
	dd LABEL_BGCOLOR_TRANSPARENT
iend
istruc LABEL						; player 2
	at LABEL.position
	dd MOS_DWORD(LABEL_PL2_X,LABEL_PL2_Y)
	dd pl2
	dd MOS_RGB(255,255,255)
	dd LABEL_BGCOLOR_TRANSPARENT
iend
statusbar:						; status bar
istruc LABEL
	at LABEL.position
	dd MOS_DWORD(LABEL_STATUS_X,LABEL_STATUS_Y)
	dd 0
	dd MOS_RGB(255,255,255)
	dd LABEL_BGCOLOR_TRANSPARENT
iend
label_pl1type:
istruc LABEL
	at LABEL.position
	%ifidn lang, 'it'
		dd MOS_DWORD(LABEL_PL1TYPE_X + 18,LABEL_PL1TYPE_Y)
	%else
		dd MOS_DWORD(LABEL_PL1TYPE_X,LABEL_PL1TYPE_Y)
	%endif
	dd playertypes+PL1TYPE_INIT*PLAYERTYPELEN
	dd MOS_RGB(255,255,255)
	dd MOS_RGB(0,0,0)
iend
label_pl2type:
istruc LABEL
	at LABEL.position
	%ifidn lang, 'it'
		dd MOS_DWORD(LABEL_PL2TYPE_X + 18,LABEL_PL2TYPE_Y)
	%else
		dd MOS_DWORD(LABEL_PL2TYPE_X,LABEL_PL2TYPE_Y)
	%endif
	dd playertypes+PL2TYPE_INIT*PLAYERTYPELEN
	dd MOS_RGB(255,255,255)
	dd MOS_RGB(0,0,0)
iend
NLABELS		equ	(($-labels)/LABEL_size)
 
 
; player types
player1_type	dd	PL1TYPE_INIT
player2_type	dd	PL2TYPE_INIT
 
 
; status messages
%ifidn lang, 'it'
	player1hmnprmpt	db	"Turno del giocatore 1",0
	player2hmnprmpt db	"Turno del giocatore 2",0
	player1cpuprmpt	db	"Attendi, giocatore 1 sta pensando...",0
	player2cpuprmpt	db	"Attendi, giocatore 2 sta pensando...",0
	itisadraw	db	"Pareggio",0
	player1wins	db	"Vince giocatore 1",0
	player2wins	db	"Vince Giocatore 2",0
%else
	player1hmnprmpt	db	"Make your move, player 1.",0
	player2hmnprmpt db	"Make your move, player 2.",0
	player1cpuprmpt	db	"Player 1 is thinking, please wait...",0
	player2cpuprmpt	db	"Player 2 is thinking, please wait...",0
	itisadraw	db	"It's a draw.",0
	player1wins	db	"Player 1 wins.",0
	player2wins	db	"Player 2 wins.",0
%endif
 
 
; pointer to ai player. future releases C4 might
; or might not support different ai players =)
aicode		dd	aiGetMove
 
 
; button images
redpcx:		incbin	"red.pcx"
REDPCXSIZE	equ	($ - redpcx)
bluepcx:	incbin	"blue.pcx"
BLUEPCXSIZE	equ	($ - bluepcx)
 
 
 
;**********************************************************
; uninitialized data
;**********************************************************
 
	section .bss
 
; player input
; 0 	:	no input available
; 1..7	:	column to drop stone into
playerinput	resd	1
 
mouseinput	resd	1
gameover	resd	1
 
redstone	resb	STONESIZE*STONESIZE*3
bluestone	resb	STONESIZE*STONESIZE*3
 
end:
up>

Rev 3494	Rev 3510
1	; C4	1	; C4
2	; Copyright (c) 2002 Thomas Mathys	2	; Copyright (c) 2002 Thomas Mathys
3	; killer@vantage.ch	3	; killer@vantage.ch
4	;	4	;
5	; This file is part of C4.	5	; This file is part of C4.
6	;	6	;
7	; C4 is free software; you can redistribute it and/or modify	7	; C4 is free software; you can redistribute it and/or modify
8	; it under the terms of the GNU General Public License as published by	8	; it under the terms of the GNU General Public License as published by
9	; the Free Software Foundation; either version 2 of the License, or	9	; the Free Software Foundation; either version 2 of the License, or
10	; (at your option) any later version.	10	; (at your option) any later version.
11	;	11	;
12	; C4 is distributed in the hope that it will be useful,	12	; C4 is distributed in the hope that it will be useful,
13	; but WITHOUT ANY WARRANTY; without even the implied warranty of	13	; but WITHOUT ANY WARRANTY; without even the implied warranty of
14	; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	; GNU General Public License for more details.	15	; GNU General Public License for more details.
16	;	16	;
17	; You should have received a copy of the GNU General Public License	17	; You should have received a copy of the GNU General Public License
18	; along with C4; if not, write to the Free Software	18	; along with C4; if not, write to the Free Software
19	; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	19	; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20		20
21	bits 32	21	bits 32
22	%include 'mos.inc'	22	%include 'mos.inc'
23	section .text	23	section .text
24	%include 'lang_nasm.inc' ;fedesco	24	%include 'lang_nasm.inc' ;fedesco
25		25
26		26
27	MOS_HEADER01 start,end	27	MOS_HEADER01 start,end
28		28
29		29
30		30
31	;**********************************************************	31	;**********************************************************
32	; magic numbers	32	; magic numbers
33	;**********************************************************	33	;**********************************************************
34		34
35	; initial player types	35	; initial player types
36	PL1TYPE_INIT equ 0	36	PL1TYPE_INIT equ 0
37	PL2TYPE_INIT equ 4	37	PL2TYPE_INIT equ 4
38		38
39	; window	39	; window
40	WND_WIDTH equ 259	40	WND_WIDTH equ 259
41	WND_HEIGHT equ 300	41	WND_HEIGHT equ 300
42	WND_WORKCOLOR equ 0	42	WND_WORKCOLOR equ 0
43		43
44	; button dimensions	44	; button dimensions
45	BUTTON_HEIGHT equ 12	45	BUTTON_HEIGHT equ 12
46		46
47	BUTTON_NEW_X equ 14	47	BUTTON_NEW_X equ 14
48	BUTTON_NEW_Y equ 30	48	BUTTON_NEW_Y equ 30
49	%if lang = 'it'	49	%ifidn lang, 'it'
50	BUTTON_NEW_WIDTH equ 56 + 28	50	BUTTON_NEW_WIDTH equ 56 + 28
51	%else	51	%else
52	BUTTON_NEW_WIDTH equ 56	52	BUTTON_NEW_WIDTH equ 56
53	%endif	53	%endif
54		54
55	BUTTON_SPIN_WIDTH equ 8	55	BUTTON_SPIN_WIDTH equ 8
56	BUTTON_PL1DN_X equ 228	56	BUTTON_PL1DN_X equ 228
57	BUTTON_PL1DN_Y equ 30	57	BUTTON_PL1DN_Y equ 30
58	BUTTON_PL1UP_X equ (BUTTON_PL1DN_X + BUTTON_SPIN_WIDTH + 1)	58	BUTTON_PL1UP_X equ (BUTTON_PL1DN_X + BUTTON_SPIN_WIDTH + 1)
59	BUTTON_PL1UP_Y equ BUTTON_PL1DN_Y	59	BUTTON_PL1UP_Y equ BUTTON_PL1DN_Y
60		60
61	BUTTON_PL2DN_X equ BUTTON_PL1DN_X	61	BUTTON_PL2DN_X equ BUTTON_PL1DN_X
62	BUTTON_PL2DN_Y equ (BUTTON_PL1DN_Y + 20)	62	BUTTON_PL2DN_Y equ (BUTTON_PL1DN_Y + 20)
63	BUTTON_PL2UP_X equ (BUTTON_PL2DN_X + BUTTON_SPIN_WIDTH + 1)	63	BUTTON_PL2UP_X equ (BUTTON_PL2DN_X + BUTTON_SPIN_WIDTH + 1)
64	BUTTON_PL2UP_Y equ BUTTON_PL2DN_Y	64	BUTTON_PL2UP_Y equ BUTTON_PL2DN_Y
65		65
66	; label dimensions	66	; label dimensions
67	%if lang = 'it'	67	%ifidn lang, 'it'
68	LABEL_PL1_X equ 90 + 10	68	LABEL_PL1_X equ 90 + 10
69	%else	69	%else
70	LABEL_PL1_X equ 90	70	LABEL_PL1_X equ 90
71	%endif	71	%endif
72	LABEL_PL1_Y equ (1 + BUTTON_PL1DN_Y + (BUTTON_HEIGHT-8)/2)	72	LABEL_PL1_Y equ (1 + BUTTON_PL1DN_Y + (BUTTON_HEIGHT-8)/2)
73	LABEL_PL2_X equ LABEL_PL1_X	73	LABEL_PL2_X equ LABEL_PL1_X
74	LABEL_PL2_Y equ (1 + BUTTON_PL2DN_Y + (BUTTON_HEIGHT-8)/2)	74	LABEL_PL2_Y equ (1 + BUTTON_PL2DN_Y + (BUTTON_HEIGHT-8)/2)
75	%if lang = 'it'	75	%ifidn lang, 'it'
76	LABEL_PL1TYPE_X equ (LABEL_PL1_X + 10*6 - 4)	76	LABEL_PL1TYPE_X equ (LABEL_PL1_X + 10*6 - 4)
77	%else	77	%else
78	LABEL_PL1TYPE_X equ (LABEL_PL1_X + 10*6)	78	LABEL_PL1TYPE_X equ (LABEL_PL1_X + 10*6)
79	%endif	79	%endif
80	LABEL_PL1TYPE_Y equ LABEL_PL1_Y	80	LABEL_PL1TYPE_Y equ LABEL_PL1_Y
81	LABEL_PL2TYPE_X equ LABEL_PL1TYPE_X	81	LABEL_PL2TYPE_X equ LABEL_PL1TYPE_X
82	LABEL_PL2TYPE_Y equ LABEL_PL2_Y	82	LABEL_PL2TYPE_Y equ LABEL_PL2_Y
83	LABEL_STATUS_X equ 14	83	LABEL_STATUS_X equ 14
84	LABEL_STATUS_Y equ 279	84	LABEL_STATUS_Y equ 279
85	LABEL_STATUS_WIDTH equ 220	85	LABEL_STATUS_WIDTH equ 220
86	LABEL_STATUS_HEIGHT equ 12	86	LABEL_STATUS_HEIGHT equ 12
87		87
88		88
89		89
90	; board and stones	90	; board and stones
91	STONESIZE equ 32 ; stone height and width	91	STONESIZE equ 32 ; stone height and width
92	GRIDX equ 14 ; upper left corner	92	GRIDX equ 14 ; upper left corner
93	GRIDY equ 70	93	GRIDY equ 70
94	GRIDSPACING equ (STONESIZE + 1) ; space between lines	94	GRIDSPACING equ (STONESIZE + 1) ; space between lines
95	GRIDHEIGHT equ (6*GRIDSPACING+1) ; total grid width and height	95	GRIDHEIGHT equ (6*GRIDSPACING+1) ; total grid width and height
96	GRIDWIDTH equ (7*GRIDSPACING+1)	96	GRIDWIDTH equ (7*GRIDSPACING+1)
97	GRIDCOLOR equ MOS_RGB(128,128,128)	97	GRIDCOLOR equ MOS_RGB(128,128,128)
98		98
99		99
100		100
101	; button id's	101	; button id's
102	BT_QUIT equ 1	102	BT_QUIT equ 1
103	BT_NEW equ 2	103	BT_NEW equ 2
104	BT_PLAYER1DN equ 3	104	BT_PLAYER1DN equ 3
105	BT_PLAYER1UP equ 4	105	BT_PLAYER1UP equ 4
106	BT_PLAYER2DN equ 5	106	BT_PLAYER2DN equ 5
107	BT_PLAYER2UP equ 6	107	BT_PLAYER2UP equ 6
108		108
109		109
110	start:	110	start:
111	jmp main	111	jmp main
112		112
113	%include "pcx.inc"	113	%include "pcx.inc"
114	%include "windows.inc"	114	%include "windows.inc"
115	%include "board.inc"	115	%include "board.inc"
116	%include "rng.inc"	116	%include "rng.inc"
117	; %include "randomai.inc"	117	; %include "randomai.inc"
118	%include "ai.inc"	118	%include "ai.inc"
119		119
120		120
121		121
122	;**********************************************************	122	;**********************************************************
123	; main program	123	; main program
124	;**********************************************************	124	;**********************************************************
125	main:	125	main:
126	call randomize	126	call randomize
127	call defineWindow	127	call defineWindow
128	call decrunchImages	128	call decrunchImages
129	call newGame	129	call newGame
130		130
131	.msgpump:	131	.msgpump:
132	; wait for event	132	; wait for event
133	mov ebx,1	133	mov ebx,1
134	mov eax,MOS_SC_WAITEVENTTIMEOUT	134	mov eax,MOS_SC_WAITEVENTTIMEOUT
135	int 0x40	135	int 0x40
136		136
137	; process events	137	; process events
138	cmp eax,MOS_EVT_REDRAW	138	cmp eax,MOS_EVT_REDRAW
139	je short .redraw	139	je short .redraw
140	cmp eax,MOS_EVT_KEY	140	cmp eax,MOS_EVT_KEY
141	je short .key	141	je short .key
142	cmp eax,MOS_EVT_BUTTON	142	cmp eax,MOS_EVT_BUTTON
143	je short .button	143	je short .button
144		144
145	call pollMouse	145	call pollMouse
146	call gameLoop	146	call gameLoop
147	jmp short .msgpump	147	jmp short .msgpump
148		148
149	.redraw:	149	.redraw:
150	call defineWindow	150	call defineWindow
151	jmp short .msgpump	151	jmp short .msgpump
152	.key:	152	.key:
153	call keyboardInput	153	call keyboardInput
154	jmp short .msgpump	154	jmp short .msgpump
155	.button:	155	.button:
156	call handleButton	156	call handleButton
157	jmp short .msgpump	157	jmp short .msgpump
158		158
159		159
160		160
161	;**********************************************************	161	;**********************************************************
162	; button handling function	162	; button handling function
163	;**********************************************************	163	;**********************************************************
164	handleButton:	164	handleButton:
165	mov eax,MOS_SC_GETPRESSEDBUTTON ; get button id	165	mov eax,MOS_SC_GETPRESSEDBUTTON ; get button id
166	int 0x40	166	int 0x40
167		167
168	cmp al,1 ; button pressed ?	168	cmp al,1 ; button pressed ?
169	je short .bye ; nope -> nothing to do	169	je short .bye ; nope -> nothing to do
170		170
171	cmp ah,BT_QUIT ; which button has been pressed ?	171	cmp ah,BT_QUIT ; which button has been pressed ?
172	je short .quit	172	je short .quit
173	cmp ah,BT_NEW	173	cmp ah,BT_NEW
174	je short .new	174	je short .new
175	cmp ah,BT_PLAYER1DN	175	cmp ah,BT_PLAYER1DN
176	je short .player1dn	176	je short .player1dn
177	cmp ah,BT_PLAYER1UP	177	cmp ah,BT_PLAYER1UP
178	je short .player1up	178	je short .player1up
179	cmp ah,BT_PLAYER2DN	179	cmp ah,BT_PLAYER2DN
180	je short .player2dn	180	je short .player2dn
181	cmp ah,BT_PLAYER2UP	181	cmp ah,BT_PLAYER2UP
182	je short .player2up	182	je short .player2up
183	.bye:	183	.bye:
184	ret	184	ret
185	.quit:	185	.quit:
186	MOS_EXIT	186	MOS_EXIT
187	.new:	187	.new:
188	call newGame	188	call newGame
189	ret	189	ret
190	.player1dn:	190	.player1dn:
191	mov eax,[player1_type] ; get current type	191	mov eax,[player1_type] ; get current type
192	or eax,eax ; already zero ?	192	or eax,eax ; already zero ?
193	jz .bla	193	jz .bla
194	dec eax ; nope -> decrement	194	dec eax ; nope -> decrement
195	mov [player1_type],eax ; write back	195	mov [player1_type],eax ; write back
196	mov edi,label_pl1type ; and update label	196	mov edi,label_pl1type ; and update label
197	call updatePlayerType	197	call updatePlayerType
198	.bla:	198	.bla:
199	ret	199	ret
200	.player1up:	200	.player1up:
201	mov eax,[player1_type] ; get current type	201	mov eax,[player1_type] ; get current type
202	cmp eax,NPLAYERTYPES-1 ; already max ?	202	cmp eax,NPLAYERTYPES-1 ; already max ?
203	je .bla2	203	je .bla2
204	inc eax ; nope -> increment	204	inc eax ; nope -> increment
205	mov [player1_type],eax ; write back	205	mov [player1_type],eax ; write back
206	mov edi,label_pl1type ; update label	206	mov edi,label_pl1type ; update label
207	call updatePlayerType	207	call updatePlayerType
208	.bla2:	208	.bla2:
209	ret	209	ret
210	.player2dn:	210	.player2dn:
211	mov eax,[player2_type] ; get current type	211	mov eax,[player2_type] ; get current type
212	or eax,eax ; already zero ?	212	or eax,eax ; already zero ?
213	jz .bla3	213	jz .bla3
214	dec eax ; nope -> decrement	214	dec eax ; nope -> decrement
215	mov [player2_type],eax ; write back	215	mov [player2_type],eax ; write back
216	mov edi,label_pl2type ; and update label	216	mov edi,label_pl2type ; and update label
217	call updatePlayerType	217	call updatePlayerType
218	.bla3:	218	.bla3:
219	ret	219	ret
220	.player2up:	220	.player2up:
221	mov eax,[player2_type]	221	mov eax,[player2_type]
222	cmp eax,NPLAYERTYPES-1	222	cmp eax,NPLAYERTYPES-1
223	je .bla4	223	je .bla4
224	inc eax	224	inc eax
225	mov [player2_type],eax	225	mov [player2_type],eax
226	mov edi,label_pl2type	226	mov edi,label_pl2type
227	call updatePlayerType	227	call updatePlayerType
228	.bla4:	228	.bla4:
229	ret	229	ret
230		230
231		231
232		232
233	;**********************************************************	233	;**********************************************************
234	; window definition function	234	; window definition function
235	;**********************************************************	235	;**********************************************************
236	defineWindow:	236	defineWindow:
237	MOS_STARTREDRAW	237	MOS_STARTREDRAW
238		238
239	mov edi,window	239	mov edi,window
240	call drawWindow	240	call drawWindow
241		241
242	mov edi,buttons	242	mov edi,buttons
243	mov ecx,NBUTTONS	243	mov ecx,NBUTTONS
244	call drawButtons	244	call drawButtons
245		245
246	mov edi,labels	246	mov edi,labels
247	mov ecx,NLABELS	247	mov ecx,NLABELS
248	call drawLabels	248	call drawLabels
249		249
250	xor eax,eax	250	xor eax,eax
251	call drawBoard	251	call drawBoard
252		252
253	MOS_ENDREDRAW	253	MOS_ENDREDRAW
254	ret	254	ret
255		255
256		256
257		257
258	;**********************************************************	258	;**********************************************************
259	; updateStatusText	259	; updateStatusText
260	;	260	;
261	; input : esi = ptr to new string	261	; input : esi = ptr to new string
262	; output : status bar is updated	262	; output : status bar is updated
263	; destroys : everything	263	; destroys : everything
264	;**********************************************************	264	;**********************************************************
265	updateStatusText:	265	updateStatusText:
266		266
267	; different text ?	267	; different text ?
268	cmp [statusbar + LABEL.caption],esi	268	cmp [statusbar + LABEL.caption],esi
269	je .bye ; nope -> bye	269	je .bye ; nope -> bye
270	mov dword [statusbar + LABEL.caption],esi ; yeah -> save & redraw	270	mov dword [statusbar + LABEL.caption],esi ; yeah -> save & redraw
271		271
272	; clear background	272	; clear background
273	mov ebx,MOS_DWORD(LABEL_STATUS_X,LABEL_STATUS_WIDTH)	273	mov ebx,MOS_DWORD(LABEL_STATUS_X,LABEL_STATUS_WIDTH)
274	mov ecx,MOS_DWORD(LABEL_STATUS_Y,LABEL_STATUS_HEIGHT)	274	mov ecx,MOS_DWORD(LABEL_STATUS_Y,LABEL_STATUS_HEIGHT)
275	xor edx,edx	275	xor edx,edx
276	mov eax,MOS_SC_DRAWBAR	276	mov eax,MOS_SC_DRAWBAR
277	int 0x40	277	int 0x40
278		278
279	; redraw label	279	; redraw label
280	mov edi,statusbar	280	mov edi,statusbar
281	mov ecx,1	281	mov ecx,1
282	call drawLabels	282	call drawLabels
283	.bye:	283	.bye:
284	ret	284	ret
285		285
286		286
287		287
288	;**********************************************************	288	;**********************************************************
289	; updatePlayerType	289	; updatePlayerType
290	; update player type label	290	; update player type label
291	; input: eax = new type	291	; input: eax = new type
292	; edi = address label structure to update	292	; edi = address label structure to update
293	;**********************************************************	293	;**********************************************************
294	updatePlayerType:	294	updatePlayerType:
295	mov ebx,PLAYERTYPELEN ; calculate type string address	295	mov ebx,PLAYERTYPELEN ; calculate type string address
296	mul ebx	296	mul ebx
297	add eax,playertypes	297	add eax,playertypes
298	mov [edi + LABEL.caption],eax ; write address	298	mov [edi + LABEL.caption],eax ; write address
299	mov ecx,1 ; and redraw label	299	mov ecx,1 ; and redraw label
300	call drawLabels	300	call drawLabels
301	ret	301	ret
302		302
303		303
304		304
305	;**********************************************************	305	;**********************************************************
306	; board drawing stuff	306	; board drawing stuff
307	;**********************************************************	307	;**********************************************************
308		308
309	; drawBoard	309	; drawBoard
310	; draw whole board	310	; draw whole board
311	;	311	;
312	; input : eax nonzero = clear board background	312	; input : eax nonzero = clear board background
313	drawBoard:	313	drawBoard:
314		314
315	; clear background ?	315	; clear background ?
316	or eax,eax	316	or eax,eax
317	jz .noclear	317	jz .noclear
318	mov ebx,MOS_DWORD(GRIDX,GRIDWIDTH)	318	mov ebx,MOS_DWORD(GRIDX,GRIDWIDTH)
319	mov ecx,MOS_DWORD(GRIDY,GRIDHEIGHT)	319	mov ecx,MOS_DWORD(GRIDY,GRIDHEIGHT)
320	mov edx,WND_WORKCOLOR	320	mov edx,WND_WORKCOLOR
321	mov eax,MOS_SC_DRAWBAR	321	mov eax,MOS_SC_DRAWBAR
322	int 0x40	322	int 0x40
323	.noclear:	323	.noclear:
324	call drawGrid	324	call drawGrid
325	call drawStones	325	call drawStones
326	ret	326	ret
327		327
328		328
329		329
330	drawGrid:	330	drawGrid:
331		331
332	; vertical lines	332	; vertical lines
333	mov ebx,MOS_DWORD(GRIDX,GRIDX)	333	mov ebx,MOS_DWORD(GRIDX,GRIDX)
334	mov ecx,MOS_DWORD(GRIDY,GRIDY+GRIDHEIGHT-1)	334	mov ecx,MOS_DWORD(GRIDY,GRIDY+GRIDHEIGHT-1)
335	mov edx,GRIDCOLOR	335	mov edx,GRIDCOLOR
336	mov eax,MOS_SC_DRAWLINE	336	mov eax,MOS_SC_DRAWLINE
337	mov esi,8	337	mov esi,8
338	.vlines:	338	.vlines:
339	int 0x40	339	int 0x40
340	add ebx,MOS_DWORD(GRIDSPACING,GRIDSPACING)	340	add ebx,MOS_DWORD(GRIDSPACING,GRIDSPACING)
341	dec esi	341	dec esi
342	jnz .vlines	342	jnz .vlines
343		343
344	; horizontal lines	344	; horizontal lines
345	mov ebx,MOS_DWORD(GRIDX,GRIDX+GRIDWIDTH-1)	345	mov ebx,MOS_DWORD(GRIDX,GRIDX+GRIDWIDTH-1)
346	mov ecx,MOS_DWORD(GRIDY,GRIDY)	346	mov ecx,MOS_DWORD(GRIDY,GRIDY)
347	mov esi,7	347	mov esi,7
348	.hlines:	348	.hlines:
349	int 0x40	349	int 0x40
350	add ecx,MOS_DWORD(GRIDSPACING,GRIDSPACING)	350	add ecx,MOS_DWORD(GRIDSPACING,GRIDSPACING)
351	dec esi	351	dec esi
352	jnz .hlines	352	jnz .hlines
353		353
354	ret	354	ret
355		355
356		356
357	drawStones:	357	drawStones:
358	mov ebx,6	358	mov ebx,6
359	.col:	359	.col:
360	mov ecx,7	360	mov ecx,7
361	.row:	361	.row:
362	call drawStone	362	call drawStone
363	loop .row	363	loop .row
364	dec ebx	364	dec ebx
365	jnz .col	365	jnz .col
366	ret	366	ret
367		367
368		368
369		369
370	; ecx = column (1..7)	370	; ecx = column (1..7)
371	; ebx = row (1..6)	371	; ebx = row (1..6)
372	drawStone:	372	drawStone:
373	pushad	373	pushad
374		374
375	; see which image to draw.	375	; see which image to draw.
376	; the image offset is stored in ebp	376	; the image offset is stored in ebp
377	mov eax,BWIDTH ; calculate address	377	mov eax,BWIDTH ; calculate address
378	mul ebx	378	mul ebx
379	add eax,ecx	379	add eax,ecx
380	mov eax,[board+eax*4] ; get stone ?	380	mov eax,[board+eax*4] ; get stone ?
381	cmp eax,EMPTY ; empty field -> nothing to do	381	cmp eax,EMPTY ; empty field -> nothing to do
382	je .bye	382	je .bye
383	mov ebp,redstone ; assume red stone	383	mov ebp,redstone ; assume red stone
384	cmp eax,PLAYER1 ; red ?	384	cmp eax,PLAYER1 ; red ?
385	je .stoneok ; yeah -> continue	385	je .stoneok ; yeah -> continue
386	mov ebp,bluestone ; nope -> use blue stone	386	mov ebp,bluestone ; nope -> use blue stone
387	.stoneok:	387	.stoneok:
388		388
389	; calculate image position (edx)	389	; calculate image position (edx)
390	mov eax,GRIDSPACING	390	mov eax,GRIDSPACING
391	dec ecx	391	dec ecx
392	mul ecx	392	mul ecx
393	add eax,GRIDX + 1	393	add eax,GRIDX + 1
394	shl eax,16	394	shl eax,16
395	mov ecx,eax	395	mov ecx,eax
396	mov eax,GRIDSPACING	396	mov eax,GRIDSPACING
397	dec ebx	397	dec ebx
398	mul ebx	398	mul ebx
399	add eax,GRIDY + 1	399	add eax,GRIDY + 1
400	mov cx,ax	400	mov cx,ax
401	mov edx,ecx	401	mov edx,ecx
402		402
403	; put image (position is already in edx)	403	; put image (position is already in edx)
404	mov ebx,ebp ; image address	404	mov ebx,ebp ; image address
405	mov ecx,MOS_DWORD(STONESIZE,STONESIZE) ; image dimensions	405	mov ecx,MOS_DWORD(STONESIZE,STONESIZE) ; image dimensions
406	mov eax,MOS_SC_PUTIMAGE	406	mov eax,MOS_SC_PUTIMAGE
407	int 0x40	407	int 0x40
408		408
409	.bye:	409	.bye:
410	popad	410	popad
411	ret	411	ret
412		412
413		413
414		414
415	decrunchImages:	415	decrunchImages:
416	mov esi,redpcx ; red stone	416	mov esi,redpcx ; red stone
417	mov edi,redstone	417	mov edi,redstone
418	mov ebx,REDPCXSIZE	418	mov ebx,REDPCXSIZE
419	call loadPCX	419	call loadPCX
420	mov esi,bluepcx ; blue stone	420	mov esi,bluepcx ; blue stone
421	mov edi,bluestone	421	mov edi,bluestone
422	mov ebx,BLUEPCXSIZE	422	mov ebx,BLUEPCXSIZE
423	call loadPCX	423	call loadPCX
424	ret	424	ret
425		425
426		426
427		427
428	resetInput:	428	resetInput:
429	mov dword [playerinput],0 ; no player input	429	mov dword [playerinput],0 ; no player input
430	mov dword [mouseinput],0	430	mov dword [mouseinput],0
431	ret	431	ret
432		432
433		433
434		434
435	;**********************************************************	435	;**********************************************************
436	; newGame	436	; newGame
437	; set up everything for a game	437	; set up everything for a game
438	;	438	;
439	; input : nothing	439	; input : nothing
440	; output : nothing	440	; output : nothing
441	; destroys : everything	441	; destroys : everything
442	;**********************************************************	442	;**********************************************************
443	newGame:	443	newGame:
444	call boardReset ; reset and redraw board	444	call boardReset ; reset and redraw board
445	mov eax,1	445	mov eax,1
446	call drawBoard	446	call drawBoard
447	call resetInput ; reset input	447	call resetInput ; reset input
448	mov dword [gameover],0 ; game is running	448	mov dword [gameover],0 ; game is running
449	ret	449	ret
450		450
451		451
452		452
453	;**********************************************************	453	;**********************************************************
454	; pollMouse	454	; pollMouse
455	; mouse polling routine	455	; mouse polling routine
456	;	456	;
457	; input : nothing	457	; input : nothing
458	; output : playerinput will be updated, if	458	; output : playerinput will be updated, if
459	; the player clicked on a valid	459	; the player clicked on a valid
460	; field	460	; field
461	; destroys : everything	461	; destroys : everything
462	;**********************************************************	462	;**********************************************************
463	pollMouse:	463	pollMouse:
464	mov ebx,2	464	mov ebx,2
465	mov eax,MOS_SC_GETMOUSEPOSITION	465	mov eax,MOS_SC_GETMOUSEPOSITION
466	int 0x40	466	int 0x40
467	and eax,1	467	and eax,1
468	jz .mousenotpressed	468	jz .mousenotpressed
469	.mousepressed:	469	.mousepressed:
470	mov dword [mouseinput],0	470	mov dword [mouseinput],0
471	call isActiveApp	471	call isActiveApp
472	or al,al	472	or al,al
473	jz .notactive1	473	jz .notactive1
474	call getMouseCol	474	call getMouseCol
475	mov [mouseinput],eax	475	mov [mouseinput],eax
476	.notactive1:	476	.notactive1:
477	ret	477	ret
478	.mousenotpressed:	478	.mousenotpressed:
479	call isActiveApp	479	call isActiveApp
480	or al,al	480	or al,al
481	jz .notactive2	481	jz .notactive2
482	call getMouseCol	482	call getMouseCol
483	cmp eax,[mouseinput]	483	cmp eax,[mouseinput]
484	jne .nonewinput	484	jne .nonewinput
485	cmp dword [playerinput],0	485	cmp dword [playerinput],0
486	jne .nonewinput	486	jne .nonewinput
487	mov [playerinput],eax	487	mov [playerinput],eax
488	.nonewinput:	488	.nonewinput:
489	.notactive2:	489	.notactive2:
490	mov dword [mouseinput],0	490	mov dword [mouseinput],0
491	ret	491	ret
492		492
493		493
494		494
495	;**********************************************************	495	;**********************************************************
496	; getMouseCol	496	; getMouseCol
497	; calculate in which column the mouse is. or so.	497	; calculate in which column the mouse is. or so.
498	;	498	;
499	; input : nothing	499	; input : nothing
500	; output : eax = 0 -> mouse outside board	500	; output : eax = 0 -> mouse outside board

Subversion Repositories Kolibri OS

(root)/programs/games/c4/trunk/c4.asm – Rev 3494 → 3510