Gra Snake napisana w asemblerze pod procesor 8086. Gra ta wykorzystuje tryb tekstowy 80x25 gdzie rysujemy znaki ASCII po pamięci.

Gra była kompilowana TASM i linkowana TLINK.

W związku z tym, że gra korzysta z trybu DOSa to należy ją odpalić pod emulatorem Dosbox http://www.dosbox.com/

Po zainstalowaniu Dosbox tworzymy sobie na dysku katalog: C:Assembler Wrzucamy do niego kod naszej gry w pliku snake.asm oraz program TASM i TLINK. TASMa i TLINK musimy sobie pobrać z Internetu.

Uruchamiamy emulator Dosbox. Musimy zamontować katalog z naszą grą wpisując poniższe polecenia: Każda nowa linia to kolejne polecenie które wpisujemy w oknie Dosbox. Ostatnie polecenie uruchamia naszego snake’a. [code=plain]mount C C:Assembler C: tasm snake tlink snake snake[/code]

Gra oferuje różne tryby szybkości poruszania się węża oraz możliwość losowania dodatkowych owoców na planszy. Standardowo na planszy cały czas są dwa czerwone owoce. Klawiszem 4 zwiększamy o jeden liczbę owoców na planszy. Klawisz 5 dodaje nam pięć owoców na planszę. Pozycja każdego kolejnego owocu jest losowana przy kolejnym ruchu węża o jedno pole. Klawisz 6 ustawia nam liczbę owoców na standardową czyli na dwa. Oznacza to, że dopiero gdy snake zje owoce znajdujące się na planszy to ponownie będą losowane kolejne owoce tak aby zawsze na planszy znajdowały się max dwa owoce.

Gra jest szczegółowo opisana komentarzami także nie powinno być problemów ze zrozumieniem kodu. Ogólnie mechanika gry opiera się na tym, że snake zapisywany jest w tablicy będącej kolejką. Każda nowa pozycja głowy węża jest dopisywana na początku kolejki zaś z jej końca pobierany jest adres ogona węża w którego miejsce wstawiany jest znak podłoża po którym porusza się wąż.

Gra kończy się w momencie gdy dotkniemy żółtej ramki planszy lub gdy wąż wjedzie na samego siebie. A także w momencie gdy zawrócimy węża o 180 stopni.

Poniżej kod gry który należy zapisać do pliku [b]snake.asm[/b] [code=plain] ;################################################################################################################### ;# Copyright (c) 2011 Webook.pl ;# The MIT License ;# Gra: Snake 2011 ;################################################################################################################### ;# Notacja w kodzie: ;# ;# pNR__NazwaProcedury ;# * p - Każda nazwa procedury zaczyna się od litery p ;# * NR - oznacza numer procedury ;# * __ - wymagane dwa podkreślenia w nazwie procedury ;# * NazwaProcedury - nazwa naszej procedury ;# ;# pNR1_petla_NR2 ;# * pNR1 - numer procedury w której występuje pętla ;# * petla - stałe oznaczenie, że to pętla ;# * NR2 - numer pętli występującej w procedurze pNR1 ;# ;# petla_Nazwa [Są to oznaczenia dla pętli umieszczonych globalnie] ;# * petla_ - oznaczenie ze to pętla ;# * Nazwa - nazwa dla pętli ;# ;# e_pNR1_NR2 ;# * e_ - oznacza, że to etykieta ;# * pNR1 - numer pętli w której występuje etykieta ;# * NR2 - numer etykiety występującej w pętli pNR1 ;# ;# e_Nazwa [Są to oznaczenie dla etykiet globalnych] ;# * e_ - oznaczenie, że to etykieta ;# * Nazwa - nazwa naszej etykiety ;# ;# z_Nazwa ;# * z_ - prefix oznaczający zmienną ;# * Nazwa - nazwa naszej zmiennej ;# ;###################################################################################################################

; Stos stos1 segment STACK dw 1024 dup(?) ; podwójne słowo, dup-duplikat ?-brak określonej wartości, pojemność 1024 szczyt label word stos1 ends

dane segment PUBLIC ; PUBLIC - segmenty o tej samej nazwie łączone są w jeden ciągły segment. Wszystkie adresy w segmencie są łączone względem jego początku.

;=== Zmienne	
; 0Dh, 0Ah - znaki nowej linii rn
z_txt_intro db "Webook.pl | 2011 Gra Snake", 0Dh, 0Ah, 0Dh, 0Ah
			db "ESC - wyjscie", 0Dh, 0Ah
			db "Strzalki - start gry, ruch wezem w dana strone", 0Dh, 0Ah, 0Dh, 0Ah				
			db " _______    _          _______    _          _______ ", 0Dh, 0Ah
			db "(  ____   ( (    /|  (  ___  )  |     /  (  ____ ", 0Dh, 0Ah
			db "| (    /  |    ( |  | (   ) |  |    / /  | (    /", 0Dh, 0Ah
			db "| (_____   |    | |  | (___) |  |  (_/ /   | (__    ", 0Dh, 0Ah
			db "(_____  )  | ( ) |  |  ___  |  |   _ (    |  __)   ", 0Dh, 0Ah
			db "      ) |  | |    |  | (   ) |  |  (     | (      ", 0Dh, 0Ah
			db "/____) |  | )    |  | )   ( |  |  /     | (____/", 0Dh, 0Ah
			db "_______)  |/    )_)  |/     |  |_/    /  (_______/", 0Dh, 0Ah, 0Dh, 0Ah
			db "1 - mala predkosc weza", 0Dh, 0Ah
			db "2 - srednia predkosc weza", 0Dh, 0Ah
			db "3 - duza predkosc weza", 0Dh, 0Ah
			db "4 - zwieksz limit owocow o jeden", 0Dh, 0Ah
			db "5 - zwieksz limit owocow o 5", 0Dh, 0Ah
			db "6 - ustaw limit owocow na 2", 0Dh, 0Ah, 0Dh, 0Ah
			db "Aby rozpoczac nacisnij dowolny klawisz...$"
	
; Długośc węża. Typ dw czyli słowo (16 bajtów ponieważ może wąż urosnąć do maksymalnie 1794 (cała plansza zarysowana. Hipotetyczna sytuacja)) 
z_dlugosc_weza dw 1  ; Domyślnie jeden ponieważ na początku taką długość ma wąż
z_odczekaj dw 0 ; Zmienna przechowujaca czas odczekania
z_kierunek db 0 ; Kierunek ruchu węża
; Kody strzałek: 75-lewo 77-prawo 72-gora 80-dol
z_lewo db 75d
z_prawo db 77d
z_gora db 72d
z_dol db 80d
z_esc db 27d
z_wynik db 0Dh, 0Ah, "KONIEC", 0Dh, 0Ah, "Zdobyles punktow: $"
z_szybkosc db 4 ; określa szybkość węża. Im mniejsza tym szybciej się wąż porusza
z_owocow_na_planszy dw 0 ; informuje ile jest owocow na planszy. Gdy będą 2 to nie będziemy dalej losować kolejnych
z_losowa1 dw 0 ; losowa liczba
z_losowa2 dw 0
z_limit_owocow dw 2 ; Ustalamy ile owocow moze byc na planszy jednoczesnie

;=== Stałe
s_kolor_ramki equ 14d ; żółty kolor dla ramki planszy
s_kolor_podloza equ 10d ; zielony jasny
s_kolor_weza equ 15d ; biały
s_kolor_owoc equ 12d ; czerwony	
s_ascii_podloze equ 176d ; kod ASCII podłoża (trawa)
s_ascii_waz equ 219d ; kod ASCII kratka zamalowana


;=== tablice
; Tablica będzie przechowywała położenie każdego z klocków będących częścią węża. 
; (80-2)*(25-2)=1796 Maksymalne zarysowanie planszy przez węża. Pomijamy ramki czyli odejmujemy dwa
; Tablice wypełniamy zerami.
; Pierwszy element tablicy to głowa węża, każdy kolejny to 
s_tab_limit equ 1794d ; Stały limit wielkosci tablicy
tab_waz dw s_tab_limit dup(0) 
; UWAGA: Opis działania
; Tablica będzie działać jak kolejka. Podczas ruchu węża w miejsce indexu 0 wstawiany będzie numer położenia głowy węża na ekranie.
; Dlasze części węża będą po prostu przesunięte w tablicy o jeden element w górę. Ostatni element będzie kasowany przy każdym kolejnym ruchu.
; Naprościej mówiąc przy każdym kolejnym ruchu węża elementy jego położenia będą się przesuwać o jeden index w górę.
; Na index 0 w tablicy wchodzi element do kolejki, a z ostatniego indexu wychodzi element z kolejki.
; W przypadku gdy wąż zje owoc to nie będzie kasowany ostatni element tablicy dzięki czemu wąż urośnie o jeden element.
; Do kontrolowania długości węża wykorzystamy zmienną pomocniczą z_dlugosc_weza
; UWAGA##### Tablica typu dw dlatego drugi element jest pod indexem 2. Będziemy skakać co dwa indexy!!

dane ends

; AT - segmenty z tym połączeniem są ładowane ; od adresu wskazanego przez wyrażenie numeryczne ; w naszym przypadku pod adresem 0B8000h znajduje ; się początek pamięci ekranu ekran segment AT 0B800h ek db ? atr db ? ekran ends

; Segment kodu code segment ; PRIVATE

assume cs:code,ds:dane,es:ekran,ss:stos1

start:
	mov	ax,seg dane ;ładujemy rejestry segmentowe DS i ES
	mov	ds,ax
	mov ax,seg ekran ;pamięć ekranu do ES
	mov	es,ax
	;mov	ax,seg code
	mov ax,stos1
	mov ss,ax
	mov sp,offset szczyt
	
	MOV	AH,0 ;wybór trybu pracy monitora
	MOV	AL,3 ;text 80x25 kolor
	INT	10H	;obsługa ekranu	
	
	
	; Ukrywamy migotający kursor
	mov ah, 1
	mov ch, 2bh
	mov cl, 0bh
	int 10h
	
	
	mov	dx,offset z_txt_intro
	mov	ah,9h ; wypisanie tekstu intro	
	int	21h	
	
	call p2__KolorujIntro ; wywołanie procedury kolorującej napis SNAKE w intro
			
	; Czeka na naciśnięcie dowolnego klawisza
	mov ah, 00h
	int 16h
	
			
	; Rysujemy plansze
	call p1__RysujPlansze
	
	
	
	; Rysujemy węża w początkowym miejscu
	mov	ek[2000],219d ; Znak ASCII blok zamalowany 
	mov atr[2000],s_kolor_weza
	
	
	call p4__LosujOwoc
	
	
	
	
	
	;### Naciśnięcie ESC spowoduje wyjście z gry
	;### Nacisnięcie strzałek powoduje start gry
	;### Jeśli naciśniemy inny klawisz to gra czeka aż naciśniemy któryś z wyżej wymienionych
	e_UruchomGre:
		mov ah,08h ; Pobiera znak z klawiatury. Będzie zapisany w AL
		int 21h ; przerwanie
		
		cmp al,z_esc ; jeśli znak to ESC to wychodzimy z programu
		; Tutaj musilismy wykonać trik z stworzeniem pomostu w skoku. Ponieważ skok "je" i inne mu podobne są krótkimi skokami
		; Powodowało to że nie można było z tego miejsca skoczyć do końca programu (relative jump out of range)
		; Dlatego wykonano pomost i użyto skoki jmp
		je e_pomost_jmp 
			jmp e_pomin_pomost
		e_pomost_jmp:
		jmp e_KoniecProgramu
		e_pomin_pomost:
		
		; Kody strzałek: 75-lewo 77-prawo 72-gora 80-dol
		cmp al,z_lewo ; strzłka w lewo	
		je e_StartWeza
		cmp al,z_prawo ; strzłka w prawo	
		je e_StartWeza
		cmp al,z_gora ; strzłka w górę	
		je e_StartWeza
		cmp al,z_dol ; strzłka w dół	
		je e_StartWeza
					
		; Jeśli doszliśmy do tego kroku to znaczy że nie przechwycono klawisza ESC ani strzałek zatem ponownie oczekujemy na naciśnięcie klawisza
		jmp e_UruchomGre 
	
	
	
	;### Wąż zaczyna ruch. Ten blok wykona się tylko przy rozpoczęciu gry
	e_StartWeza:		
		; Jeśli wskoczylismy tu z góry gdzie mamy wybór kierunku ruchu węża przy rozpoczęciu gry to znaczy że w AL mamy wartość strzałki określającej 
		; w którą stronę zaczyna ruch wąż. Zatem ładujemy do z_kierunek wartość wybranej strzałki
		mov z_kierunek,al 
		; Do pierwszego elementu tablicy ładujemy położenie początkowe naszego węża			
		mov tab_waz[0],2000d ; Jest to położenie głowy. Głowa zawsze jest pod indexem 0 w tablicy
					
	
	e_RuchWeza: ; etykieta do której skaczemy gdy wąż jest już w ruchu
		
		mov di,tab_waz[0] ; di zawiera numer pozycji w ktorej narysowana jest głowa węża
									
		mov al,z_kierunek ; ładujemy z_kierunek do AL żeby móc wykonac porównanie.
			
		cmp al,z_lewo
		jne e_pomin1 ; Jeśli nie wciśnięto lewo to skaczemy do następnego porównania
			; Ten blok się wykona jeśli wciśnieto lewo
			sub di,2 ; 
		e_pomin1:
		
		cmp al,z_prawo
		jne e_pomin2
			add di,2
		e_pomin2:
		
		cmp al,z_gora
		jne e_pomin3
			sub di,160 ; odejmujemy 160 aby przesunąc się o jeden wiersz w górę
		e_pomin3:
		
		cmp al,z_dol
		jne e_pomin4
			add di,160 ; dodajemy 160 aby przesunąc się o jeden wiersz w dół
		e_pomin4:
		
		
		push di
		push ax
		push cx
		
		; wywołujemy procedure która sprawdzi czy wąż wjechał na niedozwolony element ramke planszy
		; lub jeśli wjechał na owoc to powoduje to wydluzenie węża
		call p3__SprawdzZdarzenie
		
		; wywołujemy procedure losujaca owoc
		call p4__LosujOwoc
		
		pop cx
		pop ax
		pop di
		
		
	
	e_PobierzKlawisz:
		mov ah,01h ; Sprawdzamy czy naciśnięto klawisz
		int 16h
		jz e_NieWybranoKlawisza ; Skok jeśli liczba równa zero, czyli jeśli nie naciśnięto żadnego klawisza

		mov ah,00h
		int 16h

		cmp al,z_esc ; Porównujemy do klawisza ESC 
		je e_KoniecProgramu ; Jeśli naciśnięto ESC to skaczemy do wyjścia z gry 
		
		; Jeśli naciśnięto klawisze 1,2,3 to zmieniamy szybkość węża
		cmp al,31h
		je e_szyb_1				
		cmp al,32h
		je e_szyb_2			
		cmp al,33h
		je e_szyb_3
		
		; Jeśli naciśnięto 4 to zwiekszamy limit owocow na planszy o jeden
		; jeśli 5 to zwiekszamy limit o 5
		; jeśli naciśnięto 6 to resetujemy limit owocow na 2
		cmp al,34h ;4 - zwiekszamy limit owocow o 1
		je e_limit_owocow1				
		cmp al,35h ;5 - zwiekszamy limit owocow o 5
		je e_limit_owocow2	
		cmp al,36h ;6 - resetujemy limit owocow na 2
		je e_limit_owocow3
		
		
		mov z_kierunek,ah ; ładujemy numer naciśniętego klawisza do zmiennej informującej o kierunku ruchu
		jmp e_NieWybranoKlawisza ; skaczemy do etykiety aby pominac ustawienia szybkosci jesli nie skoczono do nich wczesniej
		
		
		; Obsługa zmiany szybkosci ruchu węża
		e_szyb_1:
			mov z_szybkosc,4 ; wolno
			jmp e_NieWybranoKlawisza
		e_szyb_2:
			mov z_szybkosc,2 ; średnia prędkość
			jmp e_NieWybranoKlawisza
		e_szyb_3:
			mov z_szybkosc,1 ; szybko
			jmp e_NieWybranoKlawisza
			
			
		; Obsługa zmiany limitu owocow na planszy
		e_limit_owocow1:
			add z_limit_owocow,1 ; dodajemy jeden
			jmp e_NieWybranoKlawisza
		e_limit_owocow2:
			add z_limit_owocow,5
			jmp e_NieWybranoKlawisza
		e_limit_owocow3:
			mov z_limit_owocow,2
			jmp e_NieWybranoKlawisza	
			
		
	e_NieWybranoKlawisza:



	; Opóźnienie. Cykl 18,2 na sekundę
	mov ah,00h
	int 1ah
	cmp dx,z_odczekaj
	jb e_PobierzKlawisz ; jb - skok gdy jest poniżej (CF=1)
	xor cx,cx
	mov cl,z_szybkosc ; Dzięki tej zmiennej będziemy mogli zmieniać sobie szybkość węża
	add dx,cx
	mov z_odczekaj,dx
	
	
	jmp e_RuchWeza ; Powtarzamy ruch węża skacząc do etykiety e_RuchWeza
	
	
	

	
	
	;mov	dx,offset tekst1
	;mov	ah,9h ; wypisanie tekstu (DOS)		
	;int	21h	; funkcja DOS
		
	;int 16h ; Wymaga naciśnięcia dowolnego klawisza aby przejść dalej
	
	e_KoniecProgramu:	
		mov	ax,4c00h;koniec programu (DOS)
		int	21h






;###################################################################################################################
;### Procedury
;### ASCII http://www.asciitable.com/

;=== Rysowanie obramowania planszy =================================================================================
p1__RysujPlansze proc
	
	;=== Ustawiamy limit ekranu, limit ile razy się pętla wykona
	mov	cx,80*25
	
	
	;=== Rysujemy tło planszy które będzie podłożem (trawa). Tło to będzie później zamalowane przez ramki planszy
	mov	si,0
	p1_petla_1:	
		mov	ek[si],s_ascii_podloze ; kod ASCII dla kropeczek, które będą udawac trawę
		mov atr[si],s_kolor_podloza ; zielony jasny
		add si,2 ; zwiększamy index o dwa
	loop p1_petla_1
	
	
	
	;=== Rysujemy górną i dolną linie obramowania planszy				
	mov	si,0 ; zaczynamy rysowanie od indexu zero
	p1_petla_2:

		; rysowanie górnej poziomej linii
		cmp si,160d
		jge e_p1_1 ; jeśli rysujemy już powyżej 80 znaku to pomijamy rysowanie (jeśli si jest większe lub równe 160 (dlatego równe bo rysujemy od 0))
			mov	ek[si],219d ; Znak ASCII blok zamalowany 				
			mov atr[si], s_kolor_ramki ; ładujemy żółty kolor
		e_p1_1:
		
		; rysowanie poziomej linii na dole ekranu
		cmp si,3840d ; 2*80*25 = 2*2000 = 4000  (od 4000 odjąc jedną linijkę tekstu 80*2 czyli 4000-160=3840)
		jnge e_p1_2 ; skok gdy nie jest większy od
			mov	ek[si],219d ; Znak ASCII blok zamalowany 
			mov atr[si],s_kolor_ramki ; ładujemy żółty kolor
		e_p1_2:
					
		add si,2 ; zwiększamy index o dwa poniważ 1-to znak ASCII a 2-to atrybut
	loop p1_petla_2
	
	
	
	;=== Rysujemy linie ponową z lewej strony
	; 23 ponieważ będziemy rysować pionową linie z pominięciem już narysowanego jednego znaku u góry i dołu ekranu
	mov	cx,23 ; limit wywołania pętli.
	mov si,160
	p1_petla_3:
		mov	ek[si],219d ; Znak ASCII blok zamalowany 
		mov atr[si],s_kolor_ramki ; ładujemy żółty kolor			
		add si,160 ; przesuwamy się o jeden cały wiersz
	loop p1_petla_3
	
	
	
	;=== Rysujemy linie ponową z prawej strony
	; 23 ponieważ będziemy rysować pionową linie z pominięciem już narysowanego jednego znaku u góry i dołu ekranu
	mov	cx,23 ; limit wywołania pętli.
	mov si,318 ; zaczynamy rysowanie od 318 czyli od drugiego wiersza i ostatniego znaku w nim. (160 + 158)
	p1_petla_4:
		mov	ek[si],219d ; Znak ASCII blok zamalowany 
		mov atr[si],s_kolor_ramki ; ładujemy żółty kolor			
		add si,160 ; przesuwamy się o jeden cały wiersz
	loop p1_petla_4
	
	

	ret ; Powrót 
p1__RysujPlansze endp





;=== Rysowanie obramowania planszy =================================================================================
p2__KolorujIntro proc

	mov	cx,80*8 ; limit wywołania pętli. Ustawiamy na 8 bo chcemy ustawic kolor dla osmiu wierszy (każdy wiersz to 80 znaków czyli 160 bo mamy atrybut)
	mov si,5*160 ; zaczynamy rysowanie od 5 wiersza bo tam zaczyna się napis SNAKE
	mov al,1d ; ładujemy kolor do AL
	p2_petla_1:
		
		; Kolor wiersza 0 jest ustawiony powyżej w AL. Pierwsza linia znaków która rysuje duzy napis SNAKE
		
		cmp si,6*160
		je e_p2_kolor_wiersza_1 ; jeśli si równe 6*160 to możemy zmienić kolor przechowywany w al
		cmp si,7*160
		je e_p2_kolor_wiersza_2
		cmp si,8*160
		je e_p2_kolor_wiersza_3
		cmp si,9*160
		je e_p2_kolor_wiersza_4
		cmp si,10*160
		je e_p2_kolor_wiersza_5
		cmp si,11*160
		je e_p2_kolor_wiersza_6
		cmp si,12*160
		je e_p2_kolor_wiersza_7
		cmp si,13*160
		je e_p2_kolor_wiersza_8
		
	
		; Przeskakujemy ustawienia kolorów. Jeśli powyżej nie nastąpił skok do zmiany koloru w rejestrze AL to pomijamy zmiane kolorów 
		; skacząc do e_p2_1 i używając koloru aktualnie przechowywanego w rejestrze AL.
		; Dzięki takiemu zabiegowi nie będziemy ustawiać rejestru AL na ten sam kolor przy każdym ponowym ustawianiu atrybutu danego znaku na ekranie
		jmp e_p2_1 
	
	
		; Po ustawieniu danego koloru w AL przeskakujemy do jego ustawienia na ekranie
		e_p2_kolor_wiersza_1:
			mov al,2d
			jmp e_p2_1 
		e_p2_kolor_wiersza_2:
			mov al,3d
			jmp e_p2_1
		e_p2_kolor_wiersza_3:
			mov al,4d
			jmp e_p2_1
		e_p2_kolor_wiersza_4:
			mov al,5d
			jmp e_p2_1
		e_p2_kolor_wiersza_5:
			mov al,6d
			jmp e_p2_1
		e_p2_kolor_wiersza_6:
			mov al,7d
			jmp e_p2_1
		e_p2_kolor_wiersza_7:
			mov al,8d
			jmp e_p2_1
		e_p2_kolor_wiersza_8:
			mov al,9d
			jmp e_p2_1
	
		
		e_p2_1:		
			mov atr[si],al ; ładujemy żółty kolor			
			add si,2 ; przesuwamy się o dwa czyli o jedną literkę
		
	loop p2_petla_1
	
	ret ; Powrót
p2__KolorujIntro endp






;=== Funkcja sprawdzająca czy dotknięto ściany lub owocu =======================================================================
; Jeśli dotknięto owocu to następuje wydłużenie węża.
; Funkcja ponadto obsługuje ruch węża i zapis jego położenia w kolejce opartej o tablicę tab_waz
p3__SprawdzZdarzenie proc

	; W di zapisany jest numer w którym postawiona będzie głowa węża. Sprawdzimy czy uderzy o ścianę
	
	cmp atr[di],s_kolor_ramki
	jne p3_pomin1 ; jeśli kolor klocka na który wstawić chcemy węża nie jest koloru ramki to przeskakujemy
		jmp p3_uderzono_w_przeszkode ; jesli wjechalismy na	ramke
	p3_pomin1:
	cmp atr[di],s_kolor_weza 
	jne p3_pomin2 ; jeśli kolor klocka na który wstawić chcemy węża nie jest koloru węża to przeskakujemy
		jmp p3_uderzono_w_przeszkode
	
	
	p3_uderzono_w_przeszkode:
		mov	dx,offset z_wynik
		mov	ah,9h ; wypisanie tekstu o końcu gry.	
		int	21h	
		
		xor ax,ax
		mov ax,z_dlugosc_weza ; ładujemy do ax dlugosc weza
		push ax ; wkładamy na stos ax
		call p5__DrukujLiczbe ; wywołujemy procedure wypisujaca wynik liczbowy
		
		
		; Czeka na naciśnięcie dowolnego klawisza
		mov ah, 00h
		int 16h
		
		jmp e_KoniecProgramu
		
		
	p3_pomin2:
	
	; Tutaj napisac sprawdzanie najechania na owoc. Ma to spowodowac ze nie wywola sie kasowanie ogona
	xor bx,bx
	; w bl będziemy przechowywac informacje czy nastąpiło zjedzenie owoca. 
	; Jeśli tak to inna będzie wywoływana pętla.
	; 0-oznacza ze nie zwiekszono dlugosci weza		
	mov bl,0 
	
	cmp atr[di],s_kolor_owoc
	jne p3_pomin3 ; jeśli nie stawiamy głowy węża na owocu to skaczemy do etykiety
		; Ten blok wykona się gdy postawiliśmy głowę węża na owocu
		; Dodajemy zwiększamy więc długość węża
		add z_dlugosc_weza,1
		mov bl,1 ; ustawiamy flagę z informacją że zwiększono długość węża bo zjedzono owoc			
		
	p3_pomin3:
		
		
		;############
		; Gdy wąż dłuższy niż 1 i nie zwiększono jego długości
		cmp z_dlugosc_weza,1
		jle e_pomin_war1_; skok gdy jest mniejszy lub rowny 1
			jmp e_pomin_war1_blok
		e_pomin_war1_: ; pomost aby wykonac dlugi skok
			jmp e_pomin_war1
			e_pomin_war1_blok:
			; Ten blok się wykona gdy wąż ma długość większą od 1
			cmp bl,0
			jne e_pomin_war2 ; skocz gdy bl nie jest rowne 0
				;###### Ten blok wykona się gdy bl=0 czyli gdy nie zjedzono owocu
				; Przenosimy elementy w tablicy o jeden index w górę, a w miejsce indexu=0 wstawimy nową głowę węża
				xor cx,cx ; czyścimy cx
				; ile razy ma się wykonać pętla. Jest to ilość operacji przeniesienia elementów w tablicy która jest naszą kolejką
				; Dlatego -1 bo nie przenosimy ostatniego elementu nigdzie dalej gdyz ma byc on nadpisany przez przedostatni element
				mov cx,z_dlugosc_weza
				sub cx,1
				
				; si będziemy zmniejszać co krok
				; -4 poniewaz ostatni element tablicy nie bedzie przenoszony poniewaz jest on kasowany jesli nie najechano na owoc. A minus 4 ponieważ tablica zaczyna się od indexu 0 i skaczemy co dwa indexy aby dostac sie do kolejnego elementu
				mov si,z_dlugosc_weza
				add si,z_dlugosc_weza ; dwukrotna dlugosc zapisujemy poniewaz idziemy po tablicy co 2 indexy
				sub si,4

				; Kasowanie ostatniego elementu z planszy
				; odbywa się przed operacją przeniesienia elementów w tablicy o jeden index w górę
				; ponieważ w czasie przeniesienia tych elementow przedostatni element przykrywa ostatni i nie mielibysmy pozniej mozliwosci odczytania jakie polozenie ma ogon weza
				push di
				xor di,di
				mov di,tab_waz[si+2] ; +2 poniewaz wyzej mielismy -4 i to bylo wybranie przedostatniego elementu a my potrzebujemy ostatni element w tablicy
				mov	ek[di],s_ascii_podloze ; Znak ASCII podłoża planszy
				mov atr[di],s_kolor_podloza															
				pop di
				
				p3_petla_1:						
											
					xor ax,ax
					mov ax,tab_waz[si] ; przedostatni element
					mov tab_waz[si+2],ax ; ostatni element przyjmuje wartosc poprzedniego
									
					sub si,2
				loop p3_petla_1
				
				
				
				
				jmp e_pomin_a ; po zakonczonej operacji skaczemy aby pominac bloki ponizsze
			e_pomin_war2:
		
		
			cmp bl,1
			jne e_pomin_a ; skocz gdy bl nie jest rowne 1
				;###### Ten blok wykona się gdy bl=1 czyli gdy zjedzono owoc
				
				sub z_owocow_na_planszy,1 ; zjedlismy owoc wiec odejmujemy z licznika
				
				; Przenosimy elementy w tablicy o jeden index w górę, a w miejsce indexu=0 wstawimy nową głowę węża
				xor cx,cx ; czyścimy cx
				; ile razy ma się wykonać pętla. Jest to ilość operacji przeniesienia elementów w tablicy która jest naszą kolejką
				; Dlatego -1 bo nie przenosimy ostatniego elementu nigdzie dalej gdyz ma byc on nadpisany przez przedostatni element
				mov cx,z_dlugosc_weza
				sub cx,1
				
				; si będziemy zmniejszać co krok
				; -4 poniewaz ostatni element tablicy nie bedzie przenoszony poniewaz jest on kasowany jesli nie najechano na owoc. A minus 4 ponieważ tablica zaczyna się od indexu 0
				mov si,z_dlugosc_weza
				add si,z_dlugosc_weza ; dwukrotna dlugosc zapisujemy poniewaz idziemy po tablicy co 2 indexy
				sub si,4 
				
				p3_petla_2:	
											
					xor ax,ax
					mov ax,tab_waz[si] ; przedostatni element
					mov tab_waz[si+2],ax ; ostatni element przyjmuje wartosc poprzedniego
					
					sub si,2
				loop p3_petla_2
				
				jmp e_pomin_a
		
		e_pomin_war1:
		
		
		
		;###############
		; Poniższy kod wykonuje się gdy wąż ma długość 1
		cmp z_dlugosc_weza,1
		jne e_pomin_a ; jeśli nie jest rowne 1
			; Ten blok wykona się gdy wąż ma długość 1
			push di ; odkladamy di na stos
			mov di,tab_waz[0] ; pobieramy numer pozycji starego polozenia glowy weza
			; wstawiamy podloze w miejsce starego polozenia glowy
			mov	ek[di],s_ascii_podloze ; Znak ASCII podłoża planszy
			mov atr[di],s_kolor_podloza
			pop di ; zdejmujemy ze stosu di, ktory nam wskazuje nowe polozenie głowy węża
			mov tab_waz[0],di ; zapisujemy glowe weza w tablicy
			jmp e_pomin_b			
		
		e_pomin_a:
			; do pierwszego elementu tablicy ładujemy nowe położenie glowy weza
			mov tab_waz[0],di
			
		e_pomin_b:
		
		; Rysujemy głowe węża
		mov	ek[di],s_ascii_waz ; Znak ASCII
		mov atr[di],s_kolor_weza
	

	ret
p3__SprawdzZdarzenie endp








;=== Funkcja losująca położenie owoca na planszy =======================================================================
; Jeśli wylosowane pole jest już zajęte to ponawiamy losowanie az trafimy 
; na puste pole czyli na podloze na ktorym bedziemy mogli postawic owoc
p4__LosujOwoc proc
	
	mov si,z_limit_owocow
	cmp z_owocow_na_planszy,si
	jge p4_pomin ; jeśli na planszy jest wiecej owocow lub tyle samo ile wynosi limit to pomijamy generowanie kolejnych owocow
	
	p4_start: ; rozpoczynamy losowanie owoca
		
		mov ah,2ch 
		int 21h ; Pobieramy czas
		; CH=godziny CL=minuty DH=sekundy DL=1/100s
		
		xor ax,ax
		mov al,dl
		; UWAGA tutaj losujemy tylko do 80 poniewaz dl moze max przyjac wartosc 100.
		; Pozniej sobie zwiekszymy dwukrotnie ta wartosc
		cmp dl,80
		jle p4_pomin2; jeśli jest mniejsze lub rowne
			; Ten blok wykona sie gdy dl ma wartosc wieksza od 80
			; Odejmiemy wtedy 20 aby miec dlugosc jednego wiersza
			sub al,20
		p4_pomin2:
		mov z_losowa1,ax ; w zmiennej zapisalismy liczbe z zakresu od 0 do 80
		add ax,z_losowa1 ; teraz ax bedzie dwukrotnoscia losowej liczby wynoszacej max 80
		mov z_losowa1,ax ; ladujemy do losowej liczby dwukrotnosc jej
		
		
		mov ah,2ch 
		int 21h ; Pobieramy czas
		
		xor ax,ax
		mov al,dl
		; UWAGA tutaj zastosowalismy odrazu 50 czyli 2x25 poniewaz dzieki temu mozemy odjac 50 od wylosowanej wiekszej liczby niz 50 i mamy pewnosc ze liczba ta jest wieksza od zera
		cmp dl,50
		jle p4_pomin3; jeśli jest mniejsze lub rowne
			; Ten blok wykona sie gdy dl ma wartosc wieksza od 50
			; Odejmiemy wtedy 50 aby miec losowy numer kolumny
			sub al,50
		p4_pomin3:
		mov z_losowa2,ax ; w zmiennej zapisalismy liczbe z zakresu od 0 do 80
		
		
		mov ax,z_losowa1
		mov bx,z_losowa2
		mul bx
		; wynik w ax
		mov si,ax
		
		cmp atr[si],s_kolor_podloza
		jne p4_start ; jeśli nie wylosowalismy podloza to skaczemy do gory. Będziemy tak długo losowac az postawimy owoc na podłożu
		
		; malujemy owoc
		mov	ek[si],219d ; Znak ASCII blok zamalowany 
		mov atr[si],s_kolor_owoc
		
		add z_owocow_na_planszy,1 ; gdy juz postawimy owoc to zwiększamy flagę o jeden
	p4_pomin:
	
	ret
p4__LosujOwoc endp




;=== Procedura wypisujaca liczbe na ekran =======================================================================
p5__DrukujLiczbe PROC
	ARG liczba:BYTE = PARAMETR
	push bp ; zapisujemy stara wartosc bp na stosie
	mov bp,sp ; do bp ladujemy sp
	xor ax,ax ; czyscimy
	xor cx,cx
	mov cl,10 ; ustawiamy na 10 ponieważ chcemy wyświetlić wynik w liczbach dziesiętnych
	mov di,0 ; 
	mov al,liczba
	p5_skok:
	div cl ; AL=(AX div cl), AH=(AX mod cl)
	xor dh,dh
	mov dl,ah
	add dl,30h ; dodajemy 30h aby były to liczby ASCII
	push dx ; dx wrzucamy na stos.
	inc di ; zwiększamy o jeden
	xor ah,ah
	cmp al,0
	jne p5_skok ; jeśli nie jest równe 0 to skaczemy do góry
	mov cx,di
	p5_skok2:
		pop dx ; zdejmujemy dx ze stosu. Będziemy go drukować
		mov ah,2 ; Funkcja 2 powoduje wypisanie wyniku na standardowe wyjście
		int 21h ; przerwanie 21h
	loop p5_skok2
	pop bp ; zdejmujemy wartosc ze stosu i ladujemy do bp
	ret PARAMETR
p5__DrukujLiczbe ENDP

code ends

end start

[/code]