forked from KolibriOS/kolibrios
2368 lines
57 KiB
NASM
2368 lines
57 KiB
NASM
;заголовок приложения
|
||
|
||
SK_SPACE equ 0x39
|
||
SK_CTRL equ 0x1D
|
||
SK_UP equ 0x48
|
||
SK_DOWN equ 0x50
|
||
SK_LEFT equ 0x4B
|
||
SK_RIGHT equ 0x4D
|
||
SK_ESC equ 0x01
|
||
|
||
|
||
INIT_PLANE_X equ 20
|
||
INIT_PLANE_Y equ 20
|
||
BACK_COLOR equ 0x9bcdfa
|
||
GROUND_COLOR equ 0x808080
|
||
BANG_COLOR equ 0xB0140E
|
||
ANIM_PLANE_BMP_PIXELS_COUNT equ 22*32*32
|
||
WINDOW_WIDTH equ 800
|
||
WINDOW_HEIGHT equ 600
|
||
GROUNG_HEIGHT equ 100
|
||
CITY_OFFSET equ (WINDOW_WIDTH-32*20)/2
|
||
MAX_BOMBS equ 8
|
||
GRAVY_ACCEL equ 1
|
||
BOMB_DELAY equ 12
|
||
MAX_LEVEL equ 5
|
||
ACKACK_BULLET_SPEED equ 17
|
||
BULLET_SIZE equ 7
|
||
MAX_SOUNDS equ 8
|
||
|
||
VOLUME_BOMBFLY equ 16
|
||
VOLUME_BOMBBANG equ 28
|
||
VOLUME_ACKACK equ 24
|
||
VOLUME_PLANE equ 48
|
||
VOLUME_ARW equ 16
|
||
|
||
|
||
use32 ; транслятор, использующий 32 разрядных команды
|
||
org 0x0 ; базовый адрес кода, всегда 0x0
|
||
db 'MENUET01' ; идентификатор исполняемого файла (8 байт)
|
||
dd 0x1 ; версия формата заголовка исполняемого файла
|
||
dd start ; адрес, на который система передаёт управление
|
||
; после загрузки приложения в память
|
||
dd i_end ; размер приложения
|
||
dd i_end ; Объем используемой памяти, для стека отведем 0х100 байт
|
||
dd i_end ; расположим позицию стека в области памяти, сразу за телом программы. Вершина стека в диапазоне памяти, указанном выше
|
||
dd 0x0, _s_current_dir ; указатель на строку с параметрами.
|
||
; если после запуска неравно нулю, приложение было
|
||
; запущено с параметрами из командной строки
|
||
|
||
; указатель на строку, в которую записан путь,
|
||
; откуда запущено приложение
|
||
;Область кода
|
||
|
||
;----------------- include -------------------------------------
|
||
|
||
include 'ssmix.inc'
|
||
|
||
;---------------------------------------------------------------------------
|
||
;----------------------------- главный цикл --------------------------------
|
||
;---------------------------------------------------------------------------
|
||
|
||
align 4
|
||
start: ;Точка входа в программу
|
||
|
||
; режим клавиатуры: скан-коды
|
||
mov eax, 66
|
||
mov ebx, 1
|
||
mov ecx, 1
|
||
int 0x40
|
||
|
||
; инициализация кучи
|
||
mov eax, 68
|
||
mov ebx, 11
|
||
int 0x40
|
||
cmp eax, 1000000 ; куча нужна минимум на ~1000кб (это с запасом)
|
||
ja heap_ok
|
||
mov eax, -1
|
||
int 0x40 ; иначе закрываем все
|
||
heap_ok:
|
||
|
||
mov eax, bmp_plane
|
||
mov ebx, 736*32*3
|
||
call convert_bmp_backcolor
|
||
mov eax, bmp_bomb
|
||
mov ebx, 96*16*3
|
||
call convert_bmp_backcolor
|
||
mov eax, bmp_tile
|
||
mov ebx, 20*20*3
|
||
call convert_bmp_backcolor
|
||
mov eax, bmp_ackack
|
||
mov ebx, 40*20*3
|
||
call convert_bmp_backcolor
|
||
|
||
call read_sounds_file
|
||
call ssmix_init
|
||
|
||
mov [_game_state], 0
|
||
|
||
redraw_window:
|
||
call draw_window
|
||
cmp [_game_state], 0
|
||
jne still_no_intro
|
||
call draw_intro
|
||
still_no_intro:
|
||
|
||
still:
|
||
; обработка событий
|
||
mov eax,11
|
||
int 0x40
|
||
cmp eax,1
|
||
je redraw_window
|
||
cmp eax,2
|
||
je key
|
||
cmp eax,3
|
||
je close_button
|
||
|
||
; пауза
|
||
mov eax,5
|
||
mov ebx,1
|
||
int 0x40
|
||
|
||
mov eax, 26
|
||
mov ebx, 9
|
||
int 0x40
|
||
mov ebx, eax
|
||
sub eax, [_last_value_timecount]
|
||
cmp eax, [_delay]
|
||
jbe still
|
||
mov [_last_value_timecount], ebx
|
||
|
||
call timer_x2
|
||
call timer_x4
|
||
|
||
; проверка на игру
|
||
cmp [_game_state], 1
|
||
jne still_no_game
|
||
; вызов процедур игрового процесса
|
||
mov eax, [_plane_health]
|
||
cmp eax, 0
|
||
jle still_no_plane
|
||
call flight_control_plane
|
||
call plane_interaction
|
||
call draw_plane
|
||
still_no_plane:
|
||
call draw_plane_health
|
||
call bomb_proc
|
||
call bang_proc
|
||
call ground_draw
|
||
call city_draw
|
||
call ackack_draw
|
||
call ackack_bullet_proc
|
||
; таймер завершения игры
|
||
call game_over_timer
|
||
still_no_game:
|
||
|
||
jmp still
|
||
|
||
|
||
key: ; обработка нажатия клавиш
|
||
mov eax,2
|
||
int 0x40
|
||
|
||
push eax
|
||
key_SPACE:
|
||
cmp ah, SK_SPACE
|
||
jne key_SPACE_end
|
||
cmp [_game_state], 1
|
||
je key_SPACE_do_a_barrel_roll
|
||
key_SPACE_start_game: ; запуск игры
|
||
mov [_game_state], 1
|
||
call init_game_state
|
||
jmp key_SPACE_end
|
||
key_SPACE_do_a_barrel_roll: ; сделать бочку
|
||
mov eax, [_plane_state]
|
||
cmp eax, 0
|
||
je key_SPACE_do_a_barrel_roll_r
|
||
cmp eax, 1
|
||
je key_SPACE_do_a_barrel_roll_l
|
||
jmp key_SPACE_end
|
||
key_SPACE_do_a_barrel_roll_r:
|
||
mov eax,[_X_plane]
|
||
cmp eax, WINDOW_WIDTH-130-32
|
||
jg key_SPACE_end
|
||
mov [_plane_state], 4
|
||
mov [_plane_state_step], 0
|
||
jmp key_SPACE_end
|
||
key_SPACE_do_a_barrel_roll_l:
|
||
mov eax,[_X_plane]
|
||
cmp eax, 130
|
||
jl key_SPACE_end
|
||
mov [_plane_state], 5
|
||
mov [_plane_state_step], 0
|
||
key_SPACE_end:
|
||
pop eax
|
||
|
||
key_CTRL:
|
||
cmp ah, SK_CTRL
|
||
jne key_CTRL_end
|
||
call bomb_drop
|
||
key_CTRL_end:
|
||
|
||
key_UP:
|
||
cmp ah, SK_UP
|
||
jne key_UP_end
|
||
cmp [_game_state], 0
|
||
jne key_UP_end
|
||
mov ebx, [_level_num]
|
||
inc ebx
|
||
mov [_level_num], ebx
|
||
cmp ebx, MAX_LEVEL
|
||
jbe key_UP_no_max
|
||
mov [_level_num], MAX_LEVEL
|
||
key_UP_no_max:
|
||
call draw_level_num
|
||
key_UP_end:
|
||
|
||
key_DOWN:
|
||
cmp ah, SK_DOWN
|
||
jne key_DOWN_end
|
||
cmp [_game_state], 0
|
||
jne key_DOWN_end
|
||
mov ebx, [_level_num]
|
||
dec ebx
|
||
mov [_level_num], ebx
|
||
cmp ebx, 1
|
||
jae key_DOWN_no_min
|
||
mov [_level_num], 1
|
||
key_DOWN_no_min:
|
||
call draw_level_num
|
||
key_DOWN_end:
|
||
|
||
|
||
key_LEFT:
|
||
cmp ah, SK_LEFT
|
||
jne key_LEFT_end
|
||
cmp [_game_state], 0
|
||
jne key_LEFT_end
|
||
mov ebx, [_set_volume]
|
||
dec ebx
|
||
cmp ebx, 0
|
||
jge @f
|
||
mov ebx, 0
|
||
@@:
|
||
mov [_set_volume], ebx
|
||
shl ebx, 4
|
||
stdcall ssmix_setvolume, ebx, ebx
|
||
call draw_volume_num
|
||
key_LEFT_end:
|
||
|
||
|
||
key_RIGHT:
|
||
cmp ah, SK_RIGHT
|
||
jne key_RIGHT_end
|
||
cmp [_game_state], 0
|
||
jne key_RIGHT_end
|
||
mov ebx, [_set_volume]
|
||
inc ebx
|
||
cmp ebx, 8
|
||
jle @f
|
||
mov ebx, 8
|
||
@@:
|
||
mov [_set_volume], ebx
|
||
shl ebx, 4
|
||
stdcall ssmix_setvolume, ebx, ebx
|
||
call draw_volume_num
|
||
key_RIGHT_end:
|
||
|
||
|
||
key_ESC:
|
||
cmp ah, SK_ESC
|
||
jne key_ESC_end
|
||
jmp close_button
|
||
key_ESC_end:
|
||
|
||
jmp still
|
||
|
||
|
||
|
||
|
||
close_button: ; завершение работы
|
||
|
||
call ssmix_release
|
||
call sounds_free_memory
|
||
; закрыть приложение
|
||
mov eax, -1
|
||
int 0x40
|
||
|
||
|
||
;---------------------------------------------------------------------------
|
||
;----------------------------- подрограммы ---------------------------------
|
||
;---------------------------------------------------------------------------
|
||
|
||
|
||
convert_bmp_backcolor: ; eax - указаталь на начало данных, ebx - размер данных
|
||
|
||
push ecx
|
||
cbb_loop:
|
||
cmp ebx, 0
|
||
jle cbb_loop_end
|
||
mov ecx, [eax]
|
||
and ecx, 0x00FFFFFF
|
||
cmp ecx, 0x00FFFFFF
|
||
jne @f
|
||
mov ecx, BACK_COLOR
|
||
mov [eax], cl
|
||
shr ecx, 8
|
||
mov [eax+1], cl
|
||
shr ecx, 8
|
||
mov [eax+2], cl
|
||
@@:
|
||
add eax, 3
|
||
sub ebx, 3
|
||
jmp cbb_loop
|
||
cbb_loop_end:
|
||
pop ecx
|
||
|
||
ret
|
||
|
||
; чтение файла со звуками
|
||
read_sounds_file:
|
||
|
||
mov edi, _s_current_dir
|
||
mov al, 0
|
||
mov ecx, 4096
|
||
repne scasb
|
||
mov dword[edi-1], 'data'
|
||
mov dword[edi+3], '.bin'
|
||
mov [_flag_bomberdatabin_ok], 1
|
||
; прочитать из файла данных количество звуков
|
||
mov [_fi_func], 0
|
||
mov [_fi_pos], 8
|
||
mov [_fi_size], 4
|
||
mov [_fi_pbuff], _count_sounds
|
||
mov [_fi_pfilename], _s_current_dir
|
||
mov eax, 70
|
||
mov ebx, file_info
|
||
int 0x40
|
||
cmp ebx, -1
|
||
jne @f
|
||
mov [_flag_bomberdatabin_ok], 0
|
||
jmp .end
|
||
@@:
|
||
; прочитать данные о смещении и размере звуков в файле, и записать их (временно) в массив звуков
|
||
mov ecx, [_count_sounds]
|
||
shl ecx, 3
|
||
mov [_fi_func], 0
|
||
mov [_fi_pos], 12
|
||
mov [_fi_size], ecx
|
||
mov [_fi_pbuff], _array_sounds
|
||
mov [_fi_pfilename], _s_current_dir
|
||
mov eax, 70
|
||
mov ebx, file_info
|
||
int 0x40
|
||
; прочитать звуки в файле и записать их в память
|
||
mov ecx, [_count_sounds]
|
||
mov esi, _array_sounds
|
||
.loop:
|
||
push ecx
|
||
; подготовить данные информационной структуры для чтения из файла
|
||
mov [_fi_func], 0
|
||
mov eax, [esi]
|
||
mov [_fi_pos], eax
|
||
mov eax, [esi+4]
|
||
mov [_fi_size], eax
|
||
; выделить память под звук, получить указатель, и изменить данные в массиве звуков
|
||
mov ecx, [esi+4]
|
||
mov eax, 68
|
||
mov ebx, 12
|
||
int 0x40
|
||
mov [esi], eax
|
||
mov ecx, [esi+4]
|
||
add ecx, eax
|
||
mov [esi+4], ecx
|
||
; прочитать сэмпл из файла
|
||
mov [_fi_pbuff], eax
|
||
mov [_fi_pfilename], _s_current_dir
|
||
mov eax, 70
|
||
mov ebx, file_info
|
||
int 0x40
|
||
pop ecx
|
||
add esi, 8
|
||
dec ecx
|
||
jnz .loop
|
||
.end:
|
||
|
||
ret
|
||
|
||
|
||
sounds_free_memory:
|
||
|
||
mov ecx, [_count_sounds]
|
||
mov esi, _array_sounds
|
||
.loop:
|
||
push ecx
|
||
; выделить память под звук, получить указатель, и изменить данные в массиве звуков
|
||
mov eax, 68
|
||
mov ebx, 13
|
||
mov ecx, [esi]
|
||
int 0x40
|
||
pop ecx
|
||
add esi, 8
|
||
dec ecx
|
||
jnz .loop
|
||
|
||
|
||
ret
|
||
|
||
|
||
init_game_state: ; инициализация игровых данных
|
||
mov [_game_over_time], 0
|
||
mov [_X_plane], INIT_PLANE_X
|
||
mov [_Y_plane], INIT_PLANE_Y
|
||
mov [_VX_plane], 4
|
||
mov [_plane_state], 0
|
||
mov [_anim_pos_plane], 0
|
||
mov [_plane_health], 100
|
||
mov [_timer_x2], 0
|
||
mov [_timer_x4], 0
|
||
mov [_bomb_count], 0
|
||
mov [_bomb_delay_time], 0
|
||
mov [_addit_VY_plane], 0
|
||
mov [_flag_air_raid_warning], 0
|
||
|
||
call load_level
|
||
|
||
; инициализация массива взрывов
|
||
mov ebx, _bang_array
|
||
xor ecx, ecx
|
||
igs_bang_array_loop:
|
||
cmp ecx, MAX_BOMBS
|
||
jae igs_bang_array_loop_end
|
||
mov eax, -1
|
||
mov [ebx], eax
|
||
add ebx, 8
|
||
inc ecx
|
||
jmp igs_bang_array_loop
|
||
igs_bang_array_loop_end:
|
||
; инициализация массива зенитных снарядов
|
||
mov ebx, _ackack_bullet
|
||
xor ecx, ecx
|
||
igs_bullet_array_loop:
|
||
cmp ecx, 32
|
||
jae igs_bullet_array_loop_end
|
||
mov eax, 0
|
||
mov [ebx], eax
|
||
add ebx, 4
|
||
inc ecx
|
||
jmp igs_bullet_array_loop
|
||
igs_bullet_array_loop_end:
|
||
|
||
; очистить экран
|
||
call draw_window
|
||
|
||
;запустить звук пропелера
|
||
cmp [_flag_bomberdatabin_ok], 1
|
||
jne @f
|
||
stdcall ssmix_playtrack, [_array_sounds+8*((( 4 ))-1)], [_array_sounds+8*((( 4 ))-1)+4], VOLUME_PLANE, VOLUME_PLANE, SSMIX_CHANMODE_REPEAT
|
||
@@:
|
||
mov [_channel_sound_plane], eax
|
||
|
||
mov [_channel_sound_arw], -1
|
||
|
||
ret
|
||
|
||
|
||
|
||
game_over:
|
||
|
||
mov [_game_over_time], 30 ; задаем задержку на game over
|
||
;вывод текста GAME OVER
|
||
mov eax,4
|
||
mov ebx,(WINDOW_WIDTH/2 - 50)*65536 + 30
|
||
mov ecx,0x80000000
|
||
mov edx,_text_game_over
|
||
int 0x40
|
||
|
||
cmp [_flag_bomberdatabin_ok], 1
|
||
jne @f
|
||
stdcall ssmix_stoptrack, [_channel_sound_plane]
|
||
@@:
|
||
|
||
ret
|
||
|
||
|
||
game_over_timer: ; таймер завершения игры, создает небольшую паузу перед остановкой игры
|
||
|
||
mov ebx, [_game_over_time]
|
||
cmp ebx, 0
|
||
je got_end
|
||
dec ebx
|
||
mov [_game_over_time], ebx
|
||
cmp ebx, 0
|
||
jg got_end
|
||
mov [_game_state], 0
|
||
cmp [_flag_bomberdatabin_ok], 1
|
||
jne @f
|
||
call ssmix_stopalltracks
|
||
@@:
|
||
call draw_window
|
||
call draw_intro
|
||
got_end:
|
||
|
||
ret
|
||
|
||
|
||
next_level: ; следующий уровень
|
||
|
||
push eax
|
||
mov [_game_over_time], 1 ; быстренько завершим игру
|
||
mov eax, [_level_num] ; на следующий уровень
|
||
inc eax
|
||
cmp eax, MAX_LEVEL
|
||
jbe next_level_no_overmax
|
||
mov eax, MAX_LEVEL
|
||
next_level_no_overmax:
|
||
mov [_level_num], eax
|
||
pop eax
|
||
|
||
ret
|
||
|
||
|
||
|
||
check_level_complete: ; проверка на завершение уровня
|
||
|
||
push eax
|
||
push ebx
|
||
push ecx
|
||
push edx
|
||
|
||
mov edx, 0 ; флаг наличия строений в городе: 0 - нет строений, 1 - есть строения
|
||
mov ebx, _city
|
||
xor ecx, ecx
|
||
clc_loop:
|
||
cmp ecx, 32
|
||
jae clc_loop_end
|
||
xor eax, eax
|
||
mov ax, [ebx]
|
||
cmp eax, 0
|
||
je clc_no_buildings
|
||
mov edx, 1
|
||
jmp clc_loop_end
|
||
clc_no_buildings:
|
||
add ebx, 2
|
||
inc ecx
|
||
jmp clc_loop
|
||
clc_loop_end :
|
||
cmp edx, 0
|
||
jne clc_end
|
||
; уровень завершен - идем на посадку
|
||
;вывод текста LEVEL COMPLETE
|
||
mov eax,4
|
||
mov ebx,(WINDOW_WIDTH/2 - 70)*65536 + 30
|
||
mov ecx,0x80000000
|
||
mov edx,_text_level_complete
|
||
int 0x40
|
||
; быстрое снижение самолета
|
||
mov [_addit_VY_plane], 3 ; задать скорость быстрого снижения
|
||
; выключить сирену
|
||
call air_raid_warning_off
|
||
clc_end:
|
||
|
||
pop edx
|
||
pop ecx
|
||
pop ebx
|
||
pop eax
|
||
|
||
ret
|
||
|
||
|
||
draw_plane_health:
|
||
|
||
mov ebx, 5*0x00010000 + 100
|
||
mov ecx, 5*0x00010000 + 10
|
||
mov edx, 0x00000000
|
||
mov eax, 13
|
||
int 0x40
|
||
|
||
mov ebx, [_plane_health]
|
||
add ebx, 5*0x00010000
|
||
mov edx, 0x00008000
|
||
int 0x40
|
||
|
||
ret
|
||
|
||
|
||
air_raid_warning_on:
|
||
push eax
|
||
cmp [_flag_air_raid_warning], 1
|
||
je .end
|
||
mov [_flag_air_raid_warning], 1
|
||
cmp [_flag_bomberdatabin_ok], 1
|
||
jne @f
|
||
stdcall ssmix_playtrack, [_array_sounds+8*((( 5 ))-1)], [_array_sounds+8*((( 5 ))-1)+4], VOLUME_ARW, VOLUME_ARW, SSMIX_CHANMODE_REPEAT
|
||
@@:
|
||
mov [_channel_sound_arw], eax
|
||
.end:
|
||
pop eax
|
||
ret
|
||
|
||
|
||
air_raid_warning_off:
|
||
cmp [_flag_air_raid_warning], 0
|
||
je .end
|
||
mov [_flag_air_raid_warning], 0
|
||
cmp [_flag_bomberdatabin_ok], 1
|
||
jne .end
|
||
stdcall ssmix_stoptrack, [_channel_sound_arw]
|
||
.end:
|
||
ret
|
||
|
||
|
||
;======================================= САМОЛЕТ ======================================
|
||
|
||
|
||
flight_control_plane: ; процедура управления полетом самолета
|
||
|
||
mov eax,[_X_plane]
|
||
add eax, [_VX_plane]
|
||
mov [_X_plane], eax
|
||
|
||
cmp eax, WINDOW_WIDTH-60-32
|
||
jl fcp_set_utunr_rl
|
||
mov ebx, [_plane_state]
|
||
cmp ebx, 0
|
||
jne fcp_set_utunr_rl
|
||
mov [_plane_state],2
|
||
mov [_plane_state_step], 0
|
||
fcp_set_utunr_rl:
|
||
|
||
cmp eax, 60
|
||
jg fcp_set_utunr_lr
|
||
mov ebx, [_plane_state]
|
||
cmp ebx, 1
|
||
jne fcp_set_utunr_lr
|
||
mov [_plane_state],3
|
||
mov [_plane_state_step], 0
|
||
fcp_set_utunr_lr:
|
||
|
||
; далее код выполняется в 2 раза медленней
|
||
mov eax, [_timer_x2]
|
||
cmp eax, 0
|
||
jne fcp_timex2_end
|
||
|
||
mov eax, [_plane_state]
|
||
cmp eax, 2 ; если делаем разворот налево
|
||
jne fcp_uturn_rl_end
|
||
mov eax, [_plane_state_step]
|
||
mov ebx, 4
|
||
sub ebx, eax
|
||
mov [_VX_plane], ebx ; то расчитываем скорость исходя из текущего шага состояния
|
||
inc eax ; переходим на следующий шаг состояния
|
||
mov [_plane_state_step], eax
|
||
cmp eax, 9 ; проверяем, закончились ли шаги
|
||
jne fcp_uturn_rl_end
|
||
mov [_plane_state], 1 ; если да то переводим состояние на прямой полет
|
||
fcp_uturn_rl_end:
|
||
|
||
|
||
mov eax, [_plane_state]
|
||
cmp eax, 3 ; если делаем разворот направо
|
||
jne fcp_uturn_lr_end
|
||
mov eax, [_plane_state_step]
|
||
mov ebx, -4
|
||
add ebx, eax
|
||
mov [_VX_plane], ebx ; то расчитываем скорость исходя из текущего шага состояния
|
||
inc eax ; переходим на следующий шаг состояния
|
||
mov [_plane_state_step], eax
|
||
cmp eax, 9 ; проверяем, закончились ли шаги
|
||
jne fcp_uturn_lr_end
|
||
mov [_plane_state], 0 ; если да то переводим состояние на прямой полет
|
||
fcp_uturn_lr_end:
|
||
|
||
mov eax, [_plane_state]
|
||
cmp eax, 4 ; если делаем бочку вправо
|
||
jne fcp_barrel_r_end
|
||
mov eax, [_plane_state_step]
|
||
inc eax ; переходим на следующий шаг состояния
|
||
mov [_plane_state_step], eax
|
||
cmp eax, 8 ; проверяем, закончились ли шаги
|
||
jne fcp_barrel_r_end
|
||
mov [_plane_state], 0 ; если да то переводим состояние на прямой полет
|
||
fcp_barrel_r_end :
|
||
|
||
mov eax, [_plane_state]
|
||
cmp eax, 5 ; если делаем бочку влево
|
||
jne fcp_barrel_l_end
|
||
mov eax, [_plane_state_step]
|
||
inc eax ; переходим на следующий шаг состояния
|
||
mov [_plane_state_step], eax
|
||
cmp eax, 8 ; проверяем, закончились ли шаги
|
||
jne fcp_barrel_l_end
|
||
mov [_plane_state], 1 ; если да то переводим состояние на прямой полет
|
||
fcp_barrel_l_end:
|
||
|
||
call animation_plane
|
||
|
||
fcp_timex2_end:
|
||
|
||
; далее код выполняется в 4 раза медленней
|
||
mov eax, [_timer_x4]
|
||
cmp eax, 0
|
||
jne fcp_timex4_end
|
||
|
||
; медленное снижение самолета
|
||
mov eax,[_Y_plane]
|
||
add eax, 1
|
||
mov [_Y_plane], eax
|
||
|
||
fcp_timex4_end:
|
||
|
||
; быстрое снижение самолета
|
||
|
||
mov eax,[_Y_plane]
|
||
mov ebx,[_addit_VY_plane]
|
||
add eax, ebx
|
||
mov [_Y_plane], eax
|
||
|
||
; контроль высоты самолета, посадка
|
||
mov eax,[_Y_plane]
|
||
cmp eax, WINDOW_HEIGHT - GROUNG_HEIGHT - 32
|
||
jl fcp_end_plane_landing
|
||
mov [_addit_VY_plane], 0 ; прекратить быстрое снижение
|
||
mov ebx, [_plane_state]
|
||
cmp ebx, 6
|
||
je fcp_end_plane_landing
|
||
cmp ebx, 0
|
||
jne fcp_horiz_fly
|
||
mov [_plane_state], 6 ; режим посадки
|
||
;jmp fcp_end_plane_landing
|
||
fcp_horiz_fly:
|
||
mov eax, WINDOW_HEIGHT - GROUNG_HEIGHT - 32
|
||
fcp_end_plane_landing:
|
||
cmp eax, WINDOW_HEIGHT - GROUNG_HEIGHT - 32 + 6
|
||
jle fcp_no_plane_underground ; проверка на то, чтобы самолет не ушел "под землю"
|
||
mov eax, WINDOW_HEIGHT - GROUNG_HEIGHT - 32 + 6
|
||
mov ebx, [_X_plane]
|
||
cmp ebx, WINDOW_WIDTH - 60-32
|
||
jl fcp_no_end_level ; проверка на то, что докатился до конца посадочной полосы
|
||
; завершение уровня
|
||
call next_level ; переход на следующий уровень
|
||
fcp_no_end_level:
|
||
fcp_no_plane_underground:
|
||
mov [_Y_plane], eax
|
||
|
||
ret
|
||
|
||
|
||
|
||
animation_plane:
|
||
|
||
; анимация самолета
|
||
|
||
; полет вправо
|
||
mov eax, [_plane_state]
|
||
cmp eax, 0
|
||
jne ap_state0_end
|
||
mov [_anim_pos_plane], 0
|
||
ap_state0_end:
|
||
|
||
; полет влево
|
||
mov eax, [_plane_state]
|
||
cmp eax, 1
|
||
jne ap_state1_end
|
||
mov [_anim_pos_plane], 8
|
||
ap_state1_end:
|
||
|
||
; анимация для разворотов и бочек
|
||
mov eax, [_plane_state]
|
||
cmp eax, 5
|
||
ja ap_state2345_end
|
||
cmp eax, 2
|
||
jb ap_state2345_end
|
||
sub eax, 2
|
||
mov ebx, eax ; умножить eax на 9
|
||
shl eax, 3
|
||
add eax, ebx
|
||
add eax, [_plane_state_step] ; прибавить номер шага
|
||
shl eax, 2 ; умножить на 4
|
||
add eax, _anim_array_uturn_rl ; получается смещение для номера требуемого кадра
|
||
mov ebx, [eax]
|
||
mov [_anim_pos_plane], ebx ; здесь вытаскиваем сам номер
|
||
ap_state2345_end:
|
||
|
||
; посадка (только вправо)
|
||
mov eax, [_plane_state]
|
||
cmp eax, 6
|
||
jne ap_state6_end
|
||
mov [_anim_pos_plane], 22
|
||
ap_state6_end:
|
||
|
||
ret
|
||
|
||
|
||
|
||
draw_plane:
|
||
|
||
; стереть предыдущее изображение
|
||
mov eax, 13
|
||
mov ebx,[_last_XY_plane]
|
||
and ebx, 0xffff0000
|
||
add ebx, 32
|
||
mov ecx,[_last_XY_plane]
|
||
shl ecx, 16
|
||
add ecx, 32
|
||
mov edx, BACK_COLOR
|
||
int 0x40
|
||
|
||
; расчет адреса картинки исходя из номера кадра _anim_pos_plane
|
||
mov ebx, [_anim_pos_plane]
|
||
shl ebx, 10
|
||
mov eax, ebx
|
||
add ebx, eax
|
||
add ebx, eax
|
||
add ebx, bmp_plane
|
||
|
||
; подготовка координат
|
||
mov edx,[_X_plane]
|
||
shl edx, 16
|
||
add edx,[_Y_plane]
|
||
mov [_last_XY_plane], edx
|
||
|
||
; вывод картинки
|
||
mov eax,7
|
||
mov ecx,32*65536+32
|
||
int 0x40
|
||
|
||
ret
|
||
|
||
|
||
plane_interaction:
|
||
|
||
push eax
|
||
push ebx
|
||
push ecx
|
||
push edx
|
||
|
||
mov eax, [_X_plane]
|
||
mov ebx, [_Y_plane]
|
||
add ebx, 16
|
||
mov ecx, [_VX_plane]
|
||
cmp ecx, 0
|
||
jl pi_no_positive_vx
|
||
add eax, 32 ; здесь в зависимости от направления полета определяем точку взаимодействия с городом
|
||
pi_no_positive_vx:
|
||
; теперь в eax и ebx координаты X,Y точки взаимодействия самолета с городом
|
||
mov edx, eax
|
||
sub eax, CITY_OFFSET
|
||
; проверка на вылет за пределы города
|
||
cmp eax, 0
|
||
jl pi_out_of_city
|
||
cmp eax, 32*20
|
||
jg pi_out_of_city
|
||
; проверка на взаимодействие с городом
|
||
add eax, 10 ; делим координату X на 20
|
||
mov ecx, eax
|
||
shr eax, 4
|
||
shr ecx, 6
|
||
sub eax, ecx
|
||
shr ecx, 2
|
||
add eax, ecx
|
||
shr ecx, 2
|
||
sub eax, ecx
|
||
dec eax ; в eax номер столбца города по которому летит бомба
|
||
mov esi, eax
|
||
shl esi, 1
|
||
add esi, _city ; в esi указатель на высоту постройки в данном столбце
|
||
mov eax, edx
|
||
; теперь сравним координату Y вершины постройки с координатой Y точки взаимодействия самолета
|
||
xor ecx, ecx
|
||
mov cx, [esi]
|
||
mov edx, ecx
|
||
shl ecx, 4
|
||
shl edx, 2
|
||
add ecx, edx
|
||
mov edx, WINDOW_HEIGHT - GROUNG_HEIGHT
|
||
sub edx, ecx ; в edx координата Y вершины постройки
|
||
cmp ebx, edx
|
||
jl pi_no_crash
|
||
; если столкновение произошло
|
||
mov [_plane_health], 0
|
||
call bang_add ; делаем взрыв
|
||
call game_over ; завершение игры
|
||
pi_no_crash:
|
||
|
||
pi_out_of_city:
|
||
|
||
pop edx
|
||
pop ecx
|
||
pop ebx
|
||
pop eax
|
||
|
||
ret
|
||
|
||
|
||
; ================================== БОМБЫ ===========================================
|
||
|
||
bomb_drop: ; процедура "бросания бомбы". создает новую бомбу, задает для нее начальные параметры.
|
||
; проверка на здоровье самолета
|
||
mov eax, [_plane_health]
|
||
cmp eax, 0
|
||
jle bomb_drop_end
|
||
; проверить на допустимые состояния самолета (нельзя во время бочки)
|
||
mov eax, [_plane_state]
|
||
cmp eax, 3
|
||
ja bomb_drop_end
|
||
; проверить выдержан ли интервал времени между бросками
|
||
mov eax, [_bomb_delay_time]
|
||
cmp eax, 0
|
||
jne bomb_drop_end
|
||
mov [_bomb_delay_time], BOMB_DELAY
|
||
; собственно, бросаем бомбу
|
||
mov eax, [_bomb_count]
|
||
cmp eax, MAX_BOMBS-1
|
||
jae bomb_drop_end
|
||
inc eax
|
||
mov [_bomb_count], eax
|
||
dec eax
|
||
shl eax, 4
|
||
add eax, _bomb_array ; здесь в еах получили указатель на начало данных о бомбе
|
||
|
||
mov ebx, [_X_plane]
|
||
mov [eax], ebx ; задание координаты X
|
||
add eax, 4
|
||
mov ebx, [_Y_plane]
|
||
add ebx, 30
|
||
mov [eax], ebx ; задание координаты Y
|
||
|
||
add eax, 4
|
||
mov ebx, [_VX_plane]
|
||
cmp ebx, 0
|
||
jge bomb_drop_pos_dir_vx
|
||
bomb_drop_neg_dir_vx:
|
||
neg ebx
|
||
shr ebx, 1
|
||
neg ebx
|
||
jmp bomb_drop_dir_vx_end
|
||
bomb_drop_pos_dir_vx:
|
||
shr ebx, 1
|
||
bomb_drop_dir_vx_end:
|
||
mov [eax], ebx ; задание вектора скорости по X
|
||
|
||
add eax, 4
|
||
mov ebx, 0
|
||
mov [eax], ebx ; задание вектора скорости по Y
|
||
|
||
push ecx
|
||
mov ecx, [_bomb_count]
|
||
dec ecx
|
||
call bombfly_sound_start
|
||
pop ecx
|
||
|
||
bomb_drop_end:
|
||
|
||
ret
|
||
|
||
|
||
bomb_proc:
|
||
; таймер интервала между бросаниями бомб
|
||
mov eax, [_bomb_delay_time]
|
||
cmp eax, 0
|
||
je bomb_proc_delay_timer_end
|
||
dec eax
|
||
mov [_bomb_delay_time], eax
|
||
bomb_proc_delay_timer_end:
|
||
; обработка движения бомб
|
||
mov eax, [_bomb_count]
|
||
cmp eax, 0
|
||
je bomb_proc_end
|
||
xor ecx, ecx
|
||
bomb_proc_loop: ; цикл обработки падения бомб
|
||
cmp ecx, [_bomb_count]
|
||
jae bomb_proc_end
|
||
mov ebx, ecx
|
||
shl ebx, 4
|
||
add ebx, _bomb_array ; получили указатель на начало данных о бомбе
|
||
|
||
call bomb_hide ; стереть предыдущее значение
|
||
|
||
; обработка
|
||
|
||
; выполняется пересчет для скорости VY текущей бомбы
|
||
|
||
add ebx, 4*3
|
||
mov eax, [_timer_x2]
|
||
cmp eax, 0
|
||
jne bomb_proc_gravity_accel_end
|
||
mov eax, [ebx]
|
||
add eax, GRAVY_ACCEL
|
||
mov [ebx], eax
|
||
bomb_proc_gravity_accel_end:
|
||
; выполняется пересчет для координат X текущей бомбы
|
||
sub ebx, 4*3
|
||
mov eax, [ebx]
|
||
add ebx, 4*2
|
||
mov edx, [ebx]
|
||
add eax, edx
|
||
sub ebx, 4*2
|
||
mov [ebx], eax
|
||
push eax
|
||
; выполняется пересчет для координат Y текущей бомбы
|
||
add ebx, 4
|
||
mov eax, [ebx]
|
||
add ebx, 4*2
|
||
mov edx, [ebx]
|
||
add eax, edx
|
||
sub ebx, 4*2
|
||
mov [ebx], eax
|
||
push eax
|
||
|
||
; взаимодействие бомб с миром
|
||
sub ebx, 4
|
||
pop edx ; координата Y
|
||
pop eax ; координата X
|
||
; проверка на выход бомб за пределы игровой зоны, бомбы просто удаляются при вылете за границы
|
||
cmp eax, 10
|
||
jle bomb_proc_delete_bomb
|
||
cmp eax, WINDOW_WIDTH - 36
|
||
jge bomb_proc_delete_bomb
|
||
; проверка на взаимодейтсвие с миром
|
||
push eax
|
||
push ebx
|
||
mov ebx, edx
|
||
call bomb_check_detonation
|
||
cmp eax, 1
|
||
pop ebx
|
||
pop eax
|
||
je bomb_proc_interaction_with_world
|
||
cmp edx, WINDOW_HEIGHT - GROUNG_HEIGHT
|
||
jae bomb_proc_interaction_with_world
|
||
jmp bomb_proc_interaction_end
|
||
bomb_proc_interaction_with_world:
|
||
push eax
|
||
push ebx
|
||
mov ebx, edx
|
||
call bang_add
|
||
call air_raid_warning_on ; включение воздушной тревоги
|
||
pop ebx
|
||
pop eax
|
||
bomb_proc_delete_bomb:
|
||
call bomb_delete ; удаляем бомбу
|
||
dec ecx ; т.к. бомбы удалена - остаемся на том же номере бомбы
|
||
mov eax, [_bomb_count]
|
||
dec eax
|
||
mov [_bomb_count], eax ; уменьшаем количество бомб
|
||
jmp bomb_proc_draw_end ; не рисуем бомбу если удалили ее
|
||
bomb_proc_interaction_end:
|
||
call bomb_draw
|
||
bomb_proc_draw_end:
|
||
|
||
inc ecx
|
||
jmp bomb_proc_loop
|
||
bomb_proc_end:
|
||
|
||
ret
|
||
|
||
|
||
bomb_delete: ; удаление данных о бомбе, в есх номер удаляемой бомбы
|
||
push eax
|
||
push ebx
|
||
push ecx
|
||
push edx
|
||
call bombfly_sound_stop
|
||
inc ecx
|
||
bomb_delete_loop:
|
||
cmp ecx, [_bomb_count]
|
||
jae bomb_delete_loop_end
|
||
mov ebx, ecx
|
||
shl ebx, 4
|
||
add ebx, _bomb_array ; получили указатель на начало данных о бомбе
|
||
dec ecx
|
||
mov edx, ecx
|
||
shl edx, 4
|
||
add edx, _bomb_array ; получили указатель на начало данных о следующей бомбе
|
||
inc ecx
|
||
; перемещение данных о следующей бомбе на место предыдущей
|
||
mov eax, [ebx]
|
||
mov [edx], eax
|
||
add ebx,4
|
||
add edx,4
|
||
mov eax, [ebx]
|
||
mov [edx], eax
|
||
add ebx,4
|
||
add edx,4
|
||
mov eax, [ebx]
|
||
mov [edx], eax
|
||
add ebx,4
|
||
add edx,4
|
||
mov eax, [ebx]
|
||
mov [edx], eax
|
||
; переход к следующей бомбе
|
||
inc ecx
|
||
jmp bomb_delete_loop
|
||
bomb_delete_loop_end:
|
||
pop edx
|
||
pop ecx
|
||
pop ebx
|
||
pop eax
|
||
|
||
ret
|
||
|
||
bomb_hide: ; стереть бомбу с экрана, ebx - указатель на начало данных о бомбе
|
||
|
||
push eax
|
||
push ebx
|
||
push ecx
|
||
push edx
|
||
mov eax, 13
|
||
mov edx, ebx
|
||
mov ebx, [edx]
|
||
shl ebx, 16
|
||
add ebx, 16
|
||
add edx, 4
|
||
mov ecx, [edx]
|
||
shl ecx, 16
|
||
add ecx, 16
|
||
mov edx, BACK_COLOR
|
||
int 0x40
|
||
pop edx
|
||
pop ecx
|
||
pop ebx
|
||
pop eax
|
||
|
||
ret
|
||
|
||
|
||
bomb_draw: ; отрисовать бомбу, ebx - указатель на начало данных о бомбе
|
||
|
||
push eax
|
||
push ebx
|
||
push ecx
|
||
push edx
|
||
|
||
; получение в edx координат бомбы
|
||
mov edx, [ebx]
|
||
shl edx, 16
|
||
add ebx, 4
|
||
mov eax, [ebx]
|
||
add edx, eax
|
||
|
||
; получение указателя на картинку бомбы в ebx (сразу с выбором нужной картинки)
|
||
add ebx, 4
|
||
mov eax, [ebx] ; здесь в eax - горизонтальная скорость бомбы
|
||
add ebx, 4
|
||
mov ecx, [ebx] ; здесь в ecx - вертикальная скорость бомбы
|
||
xor ebx, ebx
|
||
cmp ecx, 3
|
||
jl bomb_draw_midspeed_end
|
||
inc ebx
|
||
bomb_draw_midspeed_end:
|
||
cmp ecx, 9
|
||
jl bomb_draw_highspeed_end
|
||
inc ebx
|
||
bomb_draw_highspeed_end:
|
||
cmp eax, 0
|
||
jge bomb_draw_left_dir_end
|
||
add ebx, 3
|
||
bomb_draw_left_dir_end:
|
||
; теперь в ebx номер картинки бомбы
|
||
shl ebx, 8
|
||
mov eax, ebx
|
||
add ebx, eax
|
||
add ebx, eax
|
||
add ebx, bmp_bomb ; теперь в ebx указатель на картинку бомбы
|
||
|
||
; вывод картинки
|
||
mov eax,7
|
||
mov ecx,16*65536+16
|
||
int 0x40
|
||
|
||
pop edx
|
||
pop ecx
|
||
pop ebx
|
||
pop eax
|
||
|
||
ret
|
||
|
||
|
||
; взаимодействие бомб с миром
|
||
|
||
bomb_check_detonation: ; проверить бомбу с координатами: eax - координата X, eab - координата Y
|
||
; и при необходимости провести нужные разрушения (или пустой взрыв)
|
||
; в eax вернуть результат события: 0 - ничего не произшло, 1 - произошел взрыв
|
||
; (корявая реализация)
|
||
|
||
push ecx
|
||
push edx
|
||
|
||
add eax, 8
|
||
add ebx, 8
|
||
|
||
sub eax, CITY_OFFSET
|
||
; проверка на вылет за пределы города
|
||
cmp eax, 0
|
||
jl bcd_out_of_city
|
||
cmp eax, 32*20
|
||
jg bcd_out_of_city
|
||
; проверка на взаимодействие с городом
|
||
add eax, 10 ; делим координату X на 20
|
||
mov ecx, eax
|
||
shr eax, 4
|
||
shr ecx, 6
|
||
sub eax, ecx
|
||
shr ecx, 2
|
||
add eax, ecx
|
||
shr ecx, 2
|
||
sub eax, ecx
|
||
dec eax ; в eax номер столбца города по которому летит бомба
|
||
mov esi, eax
|
||
shl esi, 1
|
||
add esi, _city ; в esi указатель на высоту постройки в данном столбце
|
||
|
||
mov edx, WINDOW_HEIGHT - GROUNG_HEIGHT
|
||
sub edx, ebx
|
||
mov ebx, edx
|
||
cmp ebx, 0
|
||
jg bcd_no_neg_value_Y
|
||
xor ecx, ecx
|
||
mov cx, [esi]
|
||
xor ebx, ebx
|
||
jmp bcd_damage ; наносим разрушения
|
||
bcd_no_neg_value_Y:
|
||
add ebx, 10 ; делим координату Y на 20
|
||
mov ecx, ebx
|
||
shr ebx, 4
|
||
shr ecx, 6
|
||
sub ebx, ecx
|
||
shr ecx, 2
|
||
add ebx, ecx
|
||
shr ecx, 2
|
||
sub ebx, ecx ; в ebx высота бомбы "в плитках" над поверхностью
|
||
|
||
xor ecx, ecx
|
||
mov cx, [esi]
|
||
cmp ebx, ecx ; проверка на попадание в строение
|
||
jg bcd_no_detonation
|
||
bcd_damage: ; разрушения
|
||
;разрушение столбика в который попала бомба
|
||
mov edx, ecx
|
||
mov ecx, ebx
|
||
sub ecx, 2
|
||
cmp ecx, 0 ; просто проверка на 0, чтоб не ушло в минус
|
||
jge bcd_no_neg_value_H
|
||
xor ecx, ecx
|
||
bcd_no_neg_value_H:
|
||
mov [esi], cx ; возврат значения высоты столбца после взрыва
|
||
; зачистка взорванной области
|
||
call clear_tiles
|
||
; проверка на попадание в зенитки
|
||
call ackack_check_bombing
|
||
; разрушение соседнего столбика слева
|
||
; на данный момент имеем: eax - номер центрального (центральный - это в который непосредственно попала бомба) столбика,
|
||
; ebx - высота попадания бомбы, ecx - новая высота центрального столбика, edx - прежняя высота центрального столбика,
|
||
; esi - указатель на значение высоты центрального столбика в массиве
|
||
dec eax
|
||
cmp eax, 0
|
||
jl bcd_damage_left_end
|
||
sub esi, 2
|
||
xor ecx, ecx
|
||
mov cx, [esi] ; в ecx высота левого столбика
|
||
mov edx, ecx
|
||
push ecx
|
||
sub ecx, ebx
|
||
inc ecx
|
||
cmp ecx, 2
|
||
pop ecx
|
||
ja bcd_damage_left_end ; условие |ecx-ebx|<=1
|
||
dec ecx
|
||
cmp ecx, 0 ; просто проверка на 0, чтоб не ушло в минус
|
||
jge bcd_no_neg_value_HL
|
||
xor ecx, ecx
|
||
bcd_no_neg_value_HL:
|
||
mov [esi], cx
|
||
call clear_tiles
|
||
; проверка на попадание в зенитки
|
||
call ackack_check_bombing
|
||
bcd_damage_left_end:
|
||
|
||
; разрушение соседнего столбика справа
|
||
; на данный момент имеем: eax - номер левого столбика,
|
||
; ebx - высота попадания бомбы, ecx - новая высота левого столбика, edx - прежняя высота левого столбика,
|
||
; esi - указатель на значение высоты левого столбика в массиве
|
||
inc eax
|
||
inc eax
|
||
cmp eax, 32
|
||
jge bcd_damage_right_end
|
||
add esi, 4
|
||
xor ecx, ecx
|
||
mov cx, [esi] ; в ecx высота правого столбика
|
||
mov edx, ecx
|
||
push ecx
|
||
sub ecx, ebx
|
||
inc ecx
|
||
cmp ecx, 2
|
||
pop ecx
|
||
ja bcd_damage_right_end ; условие |ecx-ebx|<=1
|
||
dec ecx
|
||
cmp ecx, 0 ; просто проверка на 0, чтоб не ушло в минус
|
||
jge bcd_no_neg_value_HR
|
||
xor ecx, ecx
|
||
bcd_no_neg_value_HR:
|
||
mov [esi], cx
|
||
call clear_tiles
|
||
; проверка на попадание в зенитки
|
||
call ackack_check_bombing
|
||
bcd_damage_right_end:
|
||
call check_level_complete
|
||
bcd_detonation:
|
||
mov eax, 1
|
||
jmp bcd_end
|
||
bcd_no_detonation:
|
||
mov eax, 0
|
||
jmp bcd_end
|
||
bcd_out_of_city:
|
||
mov eax, 1
|
||
cmp ebx, WINDOW_HEIGHT - GROUNG_HEIGHT
|
||
jge bcd_end
|
||
mov eax, 0
|
||
bcd_end:
|
||
pop edx
|
||
pop ecx
|
||
|
||
ret
|
||
|
||
|
||
bombfly_sound_start: ; ecx - номер бомбы в массиве
|
||
|
||
push eax ebx ecx
|
||
cmp [_flag_bomberdatabin_ok], 1
|
||
jne @f
|
||
stdcall ssmix_playtrack, [_array_sounds+8*((( 1 ))-1)], [_array_sounds+8*((( 1 ))-1)+4], VOLUME_BOMBFLY, VOLUME_BOMBFLY, SSMIX_CHANMODE_SINGLE_WITHOUT_RESET
|
||
@@:
|
||
mov ebx, ecx
|
||
shl ebx, 2
|
||
add ebx, _array_bombsoundchannels
|
||
mov [ebx], eax
|
||
pop ecx ebx eax
|
||
|
||
ret
|
||
|
||
|
||
bombfly_sound_stop: ; ecx - номер бомбы в массиве
|
||
|
||
push eax ebx ecx
|
||
mov ebx, ecx
|
||
shl ebx, 2
|
||
add ebx, _array_bombsoundchannels
|
||
mov eax, [ebx]
|
||
cmp [_flag_bomberdatabin_ok], 1
|
||
jne @f
|
||
stdcall ssmix_stoptrack, eax
|
||
@@:
|
||
inc ecx
|
||
.delete_loop:
|
||
cmp ecx, MAX_BOMBS
|
||
jae .delete_loop_end
|
||
mov ebx, ecx
|
||
shl ebx, 2
|
||
add ebx, _array_bombsoundchannels
|
||
mov eax, [ebx]
|
||
mov [ebx-4], eax
|
||
inc ecx
|
||
jmp .delete_loop
|
||
.delete_loop_end:
|
||
pop ecx ebx eax
|
||
|
||
ret
|
||
|
||
; ==================================== ВЗРЫВЫ =======================================
|
||
|
||
|
||
fill_circle:
|
||
; построение заполненного круга (алгоритм Брезенхема)
|
||
; входные параметры:
|
||
; eax - координата центра по X
|
||
; ebx - координата центра по Y
|
||
; ecx - радиус
|
||
; edx - цвет
|
||
mov edi, eax
|
||
mov esi, ebx
|
||
push edx ; цвет в стек
|
||
|
||
mov eax, ecx
|
||
shl eax, 1
|
||
mov edx, 3
|
||
sub edx, eax ; D:=3-2*R
|
||
xor ebx, ebx ; теперь в ebx будет коорд X, в ecx коорд Y, в edx переменная D, в eax - промежуточные данные
|
||
|
||
fc_loop:
|
||
cmp ebx, ecx
|
||
jg fc_loop_end
|
||
; отрисовка линиями
|
||
pop eax ; цвет из стека
|
||
push edx ; D в стек
|
||
mov edx, eax ; в edx - цвет
|
||
push ebx
|
||
push ecx
|
||
; рисуем первый отрезок
|
||
mov eax, edi
|
||
sub eax, ebx
|
||
shl eax, 16
|
||
add ebx, edi
|
||
add ebx, eax ; получили концы отрезка по х
|
||
add ecx, esi
|
||
mov eax, ecx
|
||
shl eax, 16
|
||
add ecx, eax ; получили концы отрезка по y
|
||
mov eax, 38
|
||
int 0x40
|
||
pop ecx
|
||
push ecx
|
||
; рисуем второй отрезок
|
||
mov eax, esi
|
||
sub eax, ecx
|
||
mov ecx, eax
|
||
shl eax, 16
|
||
add ecx, eax ; получили концы отрезка по y
|
||
mov eax, 38
|
||
int 0x40
|
||
pop ecx
|
||
pop ebx
|
||
push ecx
|
||
push ebx ; обратить внимание! порядок загрузки координат в стек поменялся!
|
||
; рисуем третий отрезок
|
||
mov eax, edi
|
||
sub eax, ecx
|
||
shl eax, 16
|
||
add ecx, edi
|
||
add ecx, eax
|
||
mov eax, ebx
|
||
mov ebx, ecx ; получили концы отрезка по х
|
||
mov ecx, eax ; внимание! в ecx - координата x
|
||
add ecx, esi
|
||
mov eax, ecx
|
||
shl eax, 16
|
||
add ecx, eax ; получили концы отрезка по y
|
||
mov eax, 38
|
||
int 0x40
|
||
pop ecx
|
||
push ecx
|
||
; рисуем четвертый отрезок
|
||
mov eax, esi
|
||
sub eax, ecx
|
||
mov ecx, eax
|
||
shl eax, 16
|
||
add ecx, eax ; получили концы отрезка по y
|
||
mov eax, 38
|
||
int 0x40
|
||
pop ebx
|
||
pop ecx
|
||
|
||
mov eax, edx ; в eax - цвет
|
||
pop edx ; D из стека
|
||
push eax ; цвет в стек
|
||
; переход в следующей точке
|
||
cmp edx, 0
|
||
jge fc_loop_D_more_0 ; если D<0
|
||
fc_loop_D_low_0: ; то
|
||
mov eax, ebx
|
||
shl eax, 2
|
||
add edx, eax
|
||
add edx, 4 ; D:=D+4*X+6
|
||
jmp fc_loop_cmpD_end
|
||
fc_loop_D_more_0: ; иначе
|
||
mov eax, ebx
|
||
sub eax, ecx
|
||
shl eax, 2
|
||
add edx, eax
|
||
add edx, 10 ; D:=D+4*(X-Y)+10
|
||
dec ecx
|
||
fc_loop_cmpD_end: ; конец если
|
||
inc ebx
|
||
jmp fc_loop
|
||
fc_loop_end:
|
||
|
||
pop edx ; цвет из стека
|
||
|
||
ret
|
||
|
||
|
||
|
||
|
||
bang_add: ; добавить взрыв от бомбы, eax - координата X, eab - координата Y
|
||
|
||
push eax
|
||
push ebx
|
||
push ecx
|
||
push edx
|
||
|
||
shl eax, 16
|
||
add eax, ebx
|
||
mov ebx, _bang_array
|
||
xor ecx, ecx
|
||
bang_add_loop:
|
||
cmp ecx, MAX_BOMBS
|
||
jae bang_add_loop_end
|
||
mov edx, [ebx]
|
||
cmp edx, -1
|
||
jne bang_add_loop_freecheck_end
|
||
mov edx, 5*65536 + 3
|
||
mov [ebx], edx
|
||
add ebx, 4
|
||
mov [ebx], eax
|
||
cmp [_flag_bomberdatabin_ok], 1
|
||
jne @f
|
||
stdcall ssmix_playtrack, [_array_sounds+8*((( 2 ))-1)], [_array_sounds+8*((( 2 ))-1)+4], VOLUME_BOMBBANG, VOLUME_BOMBBANG, SSMIX_CHANMODE_SINGLE
|
||
@@:
|
||
jmp bang_add_loop_end
|
||
bang_add_loop_freecheck_end:
|
||
add ebx, 8
|
||
inc ecx
|
||
jmp bang_add_loop
|
||
bang_add_loop_end:
|
||
|
||
|
||
pop edx
|
||
pop ecx
|
||
pop ebx
|
||
pop eax
|
||
|
||
ret
|
||
|
||
|
||
bang_proc:
|
||
|
||
mov ebx, _bang_array
|
||
xor ecx, ecx
|
||
bang_proc_loop:
|
||
cmp ecx, MAX_BOMBS
|
||
jae bang_proc_loop_end
|
||
; проверка на наличие взрыва
|
||
mov edx, [ebx]
|
||
cmp edx, -1
|
||
je bang_proc_loop_freecheck_end
|
||
; проверка на завершение взрыва
|
||
and edx, 0x0000FFFF
|
||
cmp edx, 0
|
||
jne bang_proc_loop_endcheck_end
|
||
; здесь пишем обработку завершения взрыва
|
||
push ebx
|
||
push ecx
|
||
mov ecx, [ebx]
|
||
shr ecx, 16
|
||
add ebx, 4
|
||
mov eax, [ebx]
|
||
mov ebx, eax
|
||
shr eax, 16
|
||
and ebx, 0x0000FFFF
|
||
mov edx, BACK_COLOR
|
||
call fill_circle
|
||
pop ecx
|
||
pop ebx
|
||
mov eax, -1
|
||
mov [ebx], eax
|
||
jmp bang_proc_loop_continue
|
||
bang_proc_loop_endcheck_end:
|
||
; здесь пишем обработку взрыва
|
||
push ebx
|
||
push ecx
|
||
; задаем радиус и считаем новый
|
||
mov eax, [ebx]
|
||
mov edx, eax
|
||
shr eax, 16
|
||
mov ecx, eax
|
||
and edx, 0x0000FFFF
|
||
mov eax, edx
|
||
shl eax, 3
|
||
add eax, ecx
|
||
shl eax, 16
|
||
dec edx
|
||
add eax, edx
|
||
mov [ebx], eax
|
||
; задаем координаты
|
||
add ebx, 4
|
||
mov eax, [ebx]
|
||
mov ebx, eax
|
||
shr eax, 16
|
||
and ebx, 0x0000FFFF
|
||
;задаем цвет
|
||
mov edx, BANG_COLOR
|
||
call fill_circle
|
||
pop ecx
|
||
pop ebx
|
||
bang_proc_loop_freecheck_end:
|
||
bang_proc_loop_continue:
|
||
add ebx, 8
|
||
inc ecx
|
||
jmp bang_proc_loop
|
||
bang_proc_loop_end:
|
||
|
||
ret
|
||
|
||
; ===================================== ЗЕНИТКИ =========================================
|
||
; управление зенитками, добавление зениток, отрисовка зениток, стрельба
|
||
|
||
|
||
ackack_draw: ; отрисовка зениток
|
||
|
||
mov ebx, _ackack
|
||
xor ecx, ecx
|
||
xor esi, esi ; флаг наличия хотя бы одной зенитки (действующей или в перспективе)
|
||
ackack_draw_loop:
|
||
cmp ecx, 32
|
||
jae ackack_draw_loop_end
|
||
xor eax, eax
|
||
mov ax, [ebx]
|
||
cmp eax, 1
|
||
jne ackack_draw_continue ; если значение текущей ячейки в массиве не 1 то не рисуем зенитку
|
||
push ebx
|
||
push ecx
|
||
; в ebx получаем указатель на высоту постройки
|
||
mov ebx, ecx
|
||
shl ebx, 1
|
||
add ebx, _city ; получили указатель на высоту постройки
|
||
xor eax, eax
|
||
mov ax, [ebx] ; получили высоту постройки
|
||
cmp eax, 0
|
||
jle ackack_draw_continue2 ; если постройки нет то не рисуем зенитку
|
||
mov esi, 1
|
||
call ackack_bullet_start
|
||
; отрисовка зенитки
|
||
mov ebx, bmp_ackack ; получили указатель на картинку
|
||
cmp edx, 0
|
||
je ackack_draw_no_start_bullet
|
||
add ebx, 20*20*3 ; картинка со треляющей зениткой
|
||
ackack_draw_no_start_bullet:
|
||
; формирование координат картинки в edx
|
||
mov edx, ecx
|
||
shl edx, 4
|
||
shl ecx, 2
|
||
add edx, ecx
|
||
add edx, CITY_OFFSET
|
||
shl edx, 16
|
||
mov ecx, eax
|
||
shl eax, 4
|
||
shl ecx, 2
|
||
add eax, ecx
|
||
mov ecx, WINDOW_HEIGHT-GROUNG_HEIGHT
|
||
sub ecx, eax
|
||
sub ecx, 20 ; подняли координату на плитку выше постройки
|
||
add edx, ecx ; получили координаты
|
||
mov ecx, 20*0x00010000 + 20 ; задали размер картинки
|
||
mov eax, 7
|
||
int 0x40 ; выводим картинку
|
||
ackack_draw_continue2:
|
||
pop ecx
|
||
pop ebx
|
||
ackack_draw_continue:
|
||
add ebx, 2
|
||
inc ecx
|
||
jmp ackack_draw_loop
|
||
ackack_draw_loop_end:
|
||
|
||
cmp esi, 0
|
||
jne @f
|
||
; выключить сирену
|
||
call air_raid_warning_off
|
||
@@:
|
||
|
||
ret
|
||
|
||
|
||
ackack_check_bombing: ; проверка на подрыв зениток бомбами : eax - номер столбца
|
||
|
||
push eax
|
||
push ebx
|
||
push ecx
|
||
push edx
|
||
; проверка на попадание в столбец зенитки
|
||
mov ebx, eax
|
||
shl ebx, 1
|
||
push ebx
|
||
add ebx, _ackack
|
||
mov edx, ebx ; запомним указатель состояния зенитки в edx
|
||
xor eax, eax
|
||
mov ax, [ebx] ; в eax получили состояние зенитки
|
||
cmp eax, 1
|
||
jne acb_no_bombing ; проверка на наличие зенитки в данном столбце
|
||
xor eax, eax
|
||
mov [ebx], ax ; убираем зенитку
|
||
call ackack_next_wave
|
||
acb_no_bombing:
|
||
; проверка на полное уничножение столбца
|
||
pop ebx
|
||
add ebx, _city
|
||
xor eax, eax
|
||
mov ax, [ebx] ; в eax получили состояние зенитки
|
||
cmp eax, 0
|
||
jg acb_no_destroy_building ; проверка на наличие постройки в столбце
|
||
xor eax, eax
|
||
mov [ebx], ax ; убираем зенитку даже в перспективе
|
||
acb_no_destroy_building:
|
||
pop edx
|
||
pop ecx
|
||
pop ebx
|
||
pop eax
|
||
|
||
ret
|
||
|
||
|
||
|
||
ackack_next_wave: ; новая волна зениток
|
||
|
||
push eax
|
||
push ebx
|
||
push ecx
|
||
push edx
|
||
|
||
anw_begin:
|
||
mov ebx, _ackack
|
||
xor ecx, ecx
|
||
xor edx, edx ; флаг контроля за зенитками
|
||
anw_loop:
|
||
cmp ecx, 32
|
||
jae anw_loop_end
|
||
xor eax, eax
|
||
mov ax, [ebx]
|
||
cmp eax, 1
|
||
jle anw_continue ; если значение текущей ячейки <=1 то пропускаем
|
||
dec eax
|
||
mov [ebx], ax
|
||
cmp eax, 1
|
||
jg anw_no_active_ackack ; если значение текущей ячейки в массиве >1 то пропускаем
|
||
mov edx, 1 ; показываем что есть действующая зенитка
|
||
jmp anw_continue
|
||
anw_no_active_ackack:
|
||
cmp edx, 1
|
||
je anw_continue ; если флага 1 то пропускаем
|
||
mov edx, 2
|
||
anw_continue:
|
||
add ebx, 2
|
||
inc ecx
|
||
jmp anw_loop
|
||
anw_loop_end:
|
||
cmp edx, 2
|
||
je anw_begin
|
||
|
||
pop edx
|
||
pop ecx
|
||
pop ebx
|
||
pop eax
|
||
ret
|
||
|
||
|
||
|
||
|
||
|
||
ackack_bullet_start: ; запуск снарядов (входные: eax - высота столбца, ecx - номер столбца;
|
||
; выходные: edx - флаг нового запуска (0-нет, 1 -да)
|
||
|
||
push eax
|
||
push ebx
|
||
push ecx
|
||
|
||
cmp [_flag_air_raid_warning], 1
|
||
jne abs_no_start_bullet
|
||
|
||
; в ebx получаем указатель на положение снаряда
|
||
mov edx, eax
|
||
mov ebx, ecx
|
||
shl ebx, 2
|
||
add ebx, _ackack_bullet ; получили указатель на положение снаряда
|
||
mov eax, [ebx] ; получили положение снаряда
|
||
cmp eax, 0
|
||
jne abs_no_start_bullet ; если не 0, то не запускаем новый
|
||
; запуск снаряда
|
||
mov eax, edx ; помещаем в eax высоту постройки
|
||
; считаем координату вершины
|
||
mov ecx, eax
|
||
shl eax, 4
|
||
shl ecx, 2
|
||
add eax, ecx
|
||
mov ecx, WINDOW_HEIGHT-GROUNG_HEIGHT
|
||
sub ecx, eax
|
||
sub ecx, 20+BULLET_SIZE ; подняли координату на плитку выше постройки + высота снаяряда (в ecx - начальная координата снаряда)
|
||
mov [ebx], ecx ; задали начальную координату снаряду
|
||
|
||
cmp [_flag_bomberdatabin_ok], 1
|
||
jne @f
|
||
stdcall ssmix_playtrack, [_array_sounds+8*((( 3 ))-1)], [_array_sounds+8*((( 3 ))-1)+4], VOLUME_ACKACK,VOLUME_ACKACK , SSMIX_CHANMODE_SINGLE
|
||
@@:
|
||
|
||
mov edx, 1
|
||
jmp abs_end_start_bullet
|
||
abs_no_start_bullet:
|
||
mov edx, 0
|
||
abs_end_start_bullet:
|
||
|
||
pop ecx
|
||
pop ebx
|
||
pop eax
|
||
|
||
ret
|
||
|
||
|
||
ackack_bullet_proc: ; процедура обработки и отрисовки снарядов
|
||
|
||
mov ebx, _ackack_bullet
|
||
xor ecx, ecx
|
||
abp_loop:
|
||
cmp ecx, 32
|
||
jae abp_loop_end
|
||
mov eax, [ebx]
|
||
cmp eax, 0
|
||
je abp_continue
|
||
jl abp_low_zero
|
||
push ebx
|
||
push ecx
|
||
; стирание старого изображения
|
||
mov ebx, ecx
|
||
shl ebx, 4
|
||
shl ecx, 2
|
||
add ebx, ecx
|
||
add ebx, CITY_OFFSET
|
||
add ebx, 7 ; смещение снаряда
|
||
mov edx, ebx
|
||
shl ebx, 16
|
||
add ebx, edx ; в ebx координаты начала и конца отрезка по оси X
|
||
mov ecx, eax
|
||
mov edx, ecx
|
||
add edx, BULLET_SIZE ; прибавили длину снаряда
|
||
shl ecx, 16
|
||
add ecx, edx ; в ebx координаты начала и конца отрезка по оси Y
|
||
mov edx, BACK_COLOR
|
||
mov eax, 38
|
||
int 0x40
|
||
add ebx, 0x00050005
|
||
int 0x40
|
||
|
||
pop ecx
|
||
pop ebx
|
||
push ebx
|
||
push ecx
|
||
|
||
mov eax, [ebx]
|
||
sub eax, ACKACK_BULLET_SPEED
|
||
mov [ebx], eax
|
||
cmp eax, 0
|
||
jle abp_end_draw_bullet
|
||
|
||
call ackack_bullet_interaction_check
|
||
cmp edx, 0
|
||
je abp_no_bullet_interaction ; если не было взаимодействие то рисуем снаряды
|
||
xor eax, eax
|
||
mov [ebx], eax
|
||
jmp abp_end_draw_bullet
|
||
abp_no_bullet_interaction:
|
||
|
||
; рисуем снаряды
|
||
mov ebx, ecx
|
||
shl ebx, 4
|
||
shl ecx, 2
|
||
add ebx, ecx
|
||
add ebx, CITY_OFFSET
|
||
add ebx, 7 ; смещение снаряда
|
||
mov edx, ebx
|
||
shl ebx, 16
|
||
add ebx, edx ; в ebx координаты начала и конца отрезка по оси X
|
||
mov ecx, eax
|
||
mov edx, ecx
|
||
add edx, BULLET_SIZE ; прибавили длину снаряда
|
||
shl ecx, 16
|
||
add ecx, edx ; в ebx координаты начала и конца отрезка по оси Y
|
||
mov edx, 0x00000000
|
||
mov eax, 38
|
||
int 0x40
|
||
add ebx, 0x00050005
|
||
int 0x40
|
||
abp_end_draw_bullet:
|
||
|
||
pop ecx
|
||
pop ebx
|
||
jmp abp_continue
|
||
abp_low_zero:
|
||
xor eax, eax
|
||
mov [ebx], eax
|
||
abp_continue:
|
||
add ebx, 4
|
||
inc ecx
|
||
jmp abp_loop
|
||
abp_loop_end:
|
||
|
||
ret
|
||
|
||
|
||
ackack_bullet_interaction_check: ; проверка взаимодействия снарядов
|
||
; (входные: eax - координата снаряда по Y, ecx - номер столбца;
|
||
; выходные: edx - флаг попадания (0-нет, 1 -да))
|
||
|
||
|
||
push eax
|
||
push ebx
|
||
push ecx
|
||
|
||
; если самолет делает бочку то пропускаем
|
||
mov ebx, [_plane_health]
|
||
cmp ebx, 0
|
||
jle abic_with_plane_no
|
||
mov ebx, [_plane_state]
|
||
cmp ebx, 4
|
||
je abic_with_plane_no
|
||
cmp ebx, 5
|
||
je abic_with_plane_no
|
||
; проверка на координаты
|
||
mov ebx, [_Y_plane]
|
||
cmp eax, ebx
|
||
jl abic_with_plane_no ; если сняряд выше координаты попадяния то пропускаем
|
||
add ebx, 20 ; в ebx - координата попадания в самолет
|
||
cmp eax, ebx
|
||
jg abic_with_plane_no ; если сняряд ниже координаты попадяния то пропускаем
|
||
; считаем координату X вершины
|
||
mov edx, ecx
|
||
shl edx, 4
|
||
shl ecx, 2
|
||
add ecx, edx
|
||
add ecx, CITY_OFFSET
|
||
add ecx, 7 ; в ecx - координата X левого снаряда
|
||
mov ebx, [_X_plane]
|
||
add ebx, 32
|
||
cmp ecx, ebx
|
||
jg abic_with_plane_no
|
||
mov ebx, [_X_plane]
|
||
add ecx, 5
|
||
cmp ecx, ebx
|
||
jl abic_with_plane_no
|
||
; есть попадание!!!
|
||
mov ebx, [_plane_health]
|
||
sub ebx, 20
|
||
mov [_plane_health], ebx
|
||
cmp ebx, 0 ; проверка на game over
|
||
jg abic_no_plane_crash
|
||
mov [_plane_health], 0
|
||
mov eax, [_X_plane]
|
||
mov ebx, [_Y_plane]
|
||
call bang_add ; делаем взрыв
|
||
call game_over ; завершение игры
|
||
abic_no_plane_crash:
|
||
mov edx, 1
|
||
jmp abic_with_plane_end
|
||
abic_with_plane_no:
|
||
mov edx, 0
|
||
abic_with_plane_end:
|
||
|
||
pop ecx
|
||
pop ebx
|
||
pop eax
|
||
ret
|
||
|
||
; ===================================== МИР =========================================
|
||
|
||
ground_draw:
|
||
|
||
mov eax, 13
|
||
mov ebx, 0*0x00010000 + (WINDOW_WIDTH-10)
|
||
mov ecx, (WINDOW_HEIGHT-GROUNG_HEIGHT)*0x00010000 + (GROUNG_HEIGHT-5-20)
|
||
mov edx, GROUND_COLOR
|
||
int 0x40
|
||
|
||
mov eax, 38
|
||
mov ebx, 0*0x00010000 + (WINDOW_WIDTH-10)
|
||
mov ecx, (WINDOW_HEIGHT-GROUNG_HEIGHT)*0x00010000 + (WINDOW_HEIGHT-GROUNG_HEIGHT)
|
||
mov edx, 0x000000
|
||
int 0x40
|
||
|
||
ret
|
||
|
||
|
||
city_draw: ; отрисовка города
|
||
|
||
mov ebx, _city
|
||
xor edx, edx
|
||
city_draw_loop:
|
||
cmp edx, 32
|
||
jae city_draw_loop_end
|
||
xor eax, eax
|
||
mov ax, [ebx]
|
||
push ebx
|
||
push edx
|
||
mov ebx, bmp_tile
|
||
city_draw_loop2:
|
||
cmp eax, 0
|
||
jle city_draw_loop2_end
|
||
push eax
|
||
push edx
|
||
; формирование координат картинки в edx
|
||
mov ecx, edx
|
||
shl edx, 4
|
||
shl ecx, 2
|
||
add edx, ecx
|
||
add edx, CITY_OFFSET
|
||
shl edx, 16
|
||
mov ecx, eax
|
||
shl eax, 4
|
||
shl ecx, 2
|
||
add eax, ecx
|
||
mov ecx, WINDOW_HEIGHT-GROUNG_HEIGHT
|
||
sub ecx, eax
|
||
add edx, ecx ; получили координаты
|
||
mov ecx, 20*0x00010000 + 20 ; задали размер картинки
|
||
mov eax, 7
|
||
int 0x40 ; выводим картинку
|
||
pop edx
|
||
pop eax
|
||
dec eax
|
||
jmp city_draw_loop2
|
||
city_draw_loop2_end:
|
||
|
||
pop edx
|
||
pop ebx
|
||
add ebx, 2
|
||
inc edx
|
||
jmp city_draw_loop
|
||
city_draw_loop_end:
|
||
|
||
ret
|
||
|
||
|
||
clear_tiles: ; зачистка взорванных плиток: eax - номер столбца, ecx - нижняя плитка из удаляемых, edx - верхняя плитка из удаляемых
|
||
|
||
push eax
|
||
push ebx
|
||
push ecx
|
||
push edx
|
||
; формирование координаты X угла прямоугольника
|
||
mov ebx, eax
|
||
shl eax, 4
|
||
shl ebx, 2
|
||
add eax, ebx
|
||
add eax, CITY_OFFSET
|
||
; формирование координаты Y1 нижнего края нижней плитки
|
||
mov ebx, ecx
|
||
shl ecx, 4
|
||
shl ebx, 2
|
||
add ecx, ebx
|
||
mov ebx, WINDOW_HEIGHT-GROUNG_HEIGHT
|
||
sub ebx, ecx
|
||
mov ecx, ebx
|
||
add ecx, 20
|
||
; формирование координаты Y2 верхнего края верхней плитки
|
||
mov ebx, edx
|
||
shl edx, 4
|
||
shl ebx, 2
|
||
add edx, ebx
|
||
mov ebx, WINDOW_HEIGHT-GROUNG_HEIGHT
|
||
sub ebx, edx
|
||
mov edx, ebx
|
||
sub edx, 20 ; чтоб и зенитки стирать, если они есть
|
||
; задание координаты прямоугольника по Y=Y2 и его высоты H=Y1-Y2
|
||
sub ecx, edx
|
||
shl edx, 16
|
||
add ecx, edx
|
||
; задание координаты прямоугольника по X и его ширины 20
|
||
shl eax, 16
|
||
add eax, 20
|
||
mov ebx, eax
|
||
; отрисовка прямоугольника цвета фона
|
||
mov eax, 13
|
||
mov edx, BACK_COLOR
|
||
int 0x40
|
||
|
||
pop edx
|
||
pop ecx
|
||
pop ebx
|
||
pop eax
|
||
|
||
ret
|
||
|
||
|
||
load_level: ; загрузка уровня, в eax номер загружаемого уровня
|
||
|
||
mov eax, [_level_num]
|
||
dec eax
|
||
shl eax, 7 ; умножить на размер данных для одного уровня (128 байт)
|
||
mov ebx, levels
|
||
add ebx, eax ; в ebx указатель на начало загружаемого уровня
|
||
mov edx, cur_level
|
||
mov ecx, 0
|
||
load_level_loop:
|
||
cmp ecx, 128/4
|
||
jae load_level_loop_end
|
||
mov eax, [ebx]
|
||
mov [edx], eax
|
||
add ebx, 4
|
||
add edx, 4
|
||
inc ecx
|
||
jmp load_level_loop
|
||
load_level_loop_end:
|
||
|
||
load_level_end:
|
||
|
||
ret
|
||
|
||
; =================================== РАЗНОЕ ========================================
|
||
|
||
timer_x4:
|
||
mov eax, [_timer_x4]
|
||
inc eax
|
||
mov [_timer_x4],eax
|
||
cmp eax, 4
|
||
ja timer_x4_do
|
||
jmp timer_x4_end
|
||
timer_x4_do:
|
||
mov [_timer_x4],0
|
||
timer_x4_end:
|
||
ret
|
||
|
||
|
||
timer_x2:
|
||
mov eax, [_timer_x2]
|
||
inc eax
|
||
mov [_timer_x2],eax
|
||
cmp eax, 2
|
||
ja timer_x2_do
|
||
jmp timer_x2_end
|
||
timer_x2_do:
|
||
mov [_timer_x2],0
|
||
timer_x2_end:
|
||
ret
|
||
|
||
draw_window: ; отрисовка окна
|
||
|
||
mov eax,12
|
||
mov ebx,1
|
||
int 0x40
|
||
|
||
mov eax,0
|
||
mov ebx,100*65536+WINDOW_WIDTH
|
||
mov ecx,100*65536+WINDOW_HEIGHT
|
||
mov edx,0x34000000+BACK_COLOR
|
||
mov edi,_window_caption
|
||
int 0x40
|
||
|
||
mov eax,12
|
||
mov ebx,2
|
||
int 0x40
|
||
|
||
ret
|
||
|
||
|
||
|
||
draw_intro:
|
||
|
||
;заголовок
|
||
mov eax,4
|
||
mov ebx,(WINDOW_WIDTH/2-80)*65536 + 60
|
||
mov ecx,0x80000000
|
||
mov edx,_text_intro_title
|
||
int 0x40
|
||
|
||
;описание игры
|
||
mov eax,4
|
||
mov ebx,(WINDOW_WIDTH/2-200)*65536 + 120
|
||
mov ecx,0x80000000
|
||
mov edx,_text_intro_description1
|
||
int 0x40
|
||
|
||
|
||
;клавиши управления
|
||
mov eax,4
|
||
mov ebx,(WINDOW_WIDTH/2-60)*65536 + 200
|
||
mov ecx,0x80000000
|
||
mov edx,_text_intro_key_controls
|
||
int 0x40
|
||
|
||
mov eax,4
|
||
mov ebx,(WINDOW_WIDTH/2-70)*65536 + 230
|
||
mov ecx,0x80000000
|
||
mov edx,_text_intro_key_ctrl
|
||
int 0x40
|
||
|
||
mov eax,4
|
||
mov ebx,(WINDOW_WIDTH/2-70)*65536 + 245
|
||
mov ecx,0x80000000
|
||
mov edx,_text_intro_key_space
|
||
int 0x40
|
||
|
||
; выбор уровня
|
||
|
||
mov eax,4
|
||
mov ebx,(WINDOW_WIDTH/2-175)*65536 + 300
|
||
mov ecx,0x80000000
|
||
mov edx,_text_intro_select_level
|
||
int 0x40
|
||
|
||
mov eax,4
|
||
mov ebx,(WINDOW_WIDTH/2-25)*65536 + 320
|
||
mov ecx,0x80000000
|
||
mov edx,_text_intro_level_num
|
||
int 0x40
|
||
|
||
call draw_level_num
|
||
|
||
; установка громкости
|
||
|
||
mov eax,4
|
||
mov ebx,(WINDOW_WIDTH/2-175)*65536 + 350
|
||
mov ecx,0x80000000
|
||
mov edx,_text_intro_set_volume
|
||
int 0x40
|
||
|
||
mov eax,4
|
||
mov ebx,(WINDOW_WIDTH/2-25)*65536 + 370
|
||
mov ecx,0x80000000
|
||
mov edx,_text_intro_volume_num
|
||
int 0x40
|
||
call draw_volume_num
|
||
|
||
; запуск игры и выход
|
||
|
||
mov eax,4
|
||
mov ebx,(WINDOW_WIDTH/2-80)*65536 + 400
|
||
mov ecx,0x80FF0000
|
||
mov edx,_text_intro_start_space
|
||
int 0x40
|
||
|
||
mov eax,4
|
||
mov ebx,(WINDOW_WIDTH/2-30)*65536 + 460
|
||
mov ecx,0x80000000
|
||
mov edx,_text_intro_exit_key
|
||
int 0x40
|
||
|
||
|
||
ret
|
||
|
||
|
||
draw_level_num:
|
||
|
||
mov eax, 13
|
||
mov ebx, (WINDOW_WIDTH/2+25)*0x00010000 + 30
|
||
mov ecx, 320*0x00010000 + 15
|
||
mov edx, BACK_COLOR
|
||
int 0x40
|
||
|
||
mov eax, 47
|
||
mov ebx, 0x80020000
|
||
mov ecx, [_level_num]
|
||
mov edx, (WINDOW_WIDTH/2+25)*65536 + 320
|
||
mov esi,0x00000000
|
||
int 0x40
|
||
|
||
ret
|
||
|
||
draw_volume_num:
|
||
|
||
mov eax, 13
|
||
mov ebx, (WINDOW_WIDTH/2+25)*0x00010000 + 30
|
||
mov ecx, 370*0x00010000 + 15
|
||
mov edx, BACK_COLOR
|
||
int 0x40
|
||
|
||
mov eax, 47
|
||
mov ebx, 0x80020000
|
||
mov ecx, [_set_volume]
|
||
mov edx, (WINDOW_WIDTH/2+25)*65536 + 370
|
||
mov esi,0x00000000
|
||
int 0x40
|
||
|
||
ret
|
||
|
||
;---------------------------------------------------------------------------
|
||
;-------------------------------- данные -----------------------------------
|
||
;---------------------------------------------------------------------------
|
||
|
||
_game_state dd ?
|
||
_delay dd 6
|
||
_timer_x2 dd ?
|
||
_timer_x4 dd ?
|
||
_game_over_time dd ?
|
||
_flag_air_raid_warning dd ?
|
||
_flag_bomberdatabin_ok dd ?
|
||
_last_value_timecount dd ?
|
||
|
||
_X_plane dd ?
|
||
_Y_plane dd ?
|
||
_last_XY_plane dd ?
|
||
_VX_plane dd ?
|
||
_addit_VY_plane dd ?
|
||
_plane_state dd ? ; 0 - полет направо, 1- полет налево, 2-разворот справа-налево, 3-разворот слева-направо, 4 - бочка вправо, 5 - бочка влево
|
||
_plane_state_step dd ? ; номер шага текущего состояния (нужно для синхнопизации с анимацией)
|
||
_plane_health dd ? ; здоровье самолета
|
||
|
||
_bomb_count dd ?
|
||
_bomb_array rd 4*MAX_BOMBS
|
||
_bomb_delay_time dd ? ; задержка времени на сброс бомбы
|
||
|
||
_bang_array rd 2*MAX_BOMBS
|
||
|
||
_anim_pos_plane dd ?
|
||
; последовательности картинок анимации
|
||
_anim_array_uturn_rl dd 0,1,2,3,4,5,6,7,8
|
||
_anim_array_uturn_lr dd 8,7,6,9,10,11,2,1,0
|
||
_anim_array_barrel_r dd 0,1,2,12,13,14,15,16,0
|
||
_anim_array_barrel_l dd 8,17,18,19,20,21,6,7,8
|
||
|
||
|
||
cur_level:
|
||
; массив, в котором храниться текущее состояние города. изначально в него загрузаются уровни
|
||
_city rw 32
|
||
; массив, в котором храниться текущее состояние зениток. изначально в него загрузаются уровни
|
||
_ackack rw 32
|
||
; массив, в котором хранятся значения текущих координа снарядов от зениток
|
||
_ackack_bullet rd 32
|
||
|
||
; номер текущего уровня
|
||
_level_num dd 1
|
||
; задание уровней: 32 числа означают высоту строений (высота "в квадратах") для _level?_city
|
||
; и порядок появления зениток для _level?_ackack
|
||
levels:
|
||
_level1_city dw 0, 0, 0, 6, 5, 6, 5, 6, 3, 3, 3, 3, 3, 6, 7, 8, 8, 7, 6, 3, 3, 3, 3, 3, 6, 5, 6, 5, 6, 0, 0, 0
|
||
_level1_ackack dw 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||
|
||
_level2_city dw 0, 0, 0, 5, 5, 2, 5, 7, 7, 2, 7, 9, 9, 9, 2, 9, 9, 2, 9, 9, 9, 7, 2, 7, 7, 5, 2, 5, 5, 0, 0, 0
|
||
_level2_ackack dw 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 5, 0, 0, 6, 0, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 0, 0
|
||
|
||
_level3_city dw 0, 0, 0,12,12,12, 9, 9, 9,12,12,12, 9, 7, 5, 3, 3, 5, 7, 9,12,12,12, 9, 9, 9,12,12,12, 0, 0, 0
|
||
_level3_ackack dw 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 4, 0, 3, 0, 2, 1, 1, 2, 0, 3, 0, 5, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0
|
||
|
||
_level4_city dw 0, 0, 0,12,12,12, 3,12,12,12, 3, 1, 1, 6,12,18, 18,12, 6, 1, 1, 3,12,12,12, 3,12,12,12, 0, 0, 0
|
||
_level4_ackack dw 0, 0, 0, 0, 5, 0, 1, 0, 0, 0, 1, 0, 3, 0, 0, 2, 6, 0, 0, 3, 0, 1, 0, 4, 0, 1, 0, 0, 0, 0, 0, 0
|
||
|
||
_level5_city dw 0, 5,10,10,10,10,15,15,15,15,17,17,17,17, 1,15, 15, 1,17,17,17,17,15,15,15,15,10,10,10,10, 5, 0
|
||
_level5_ackack dw 0, 8, 0, 9, 9, 0, 3, 3, 3, 3, 0, 0, 0, 0, 5, 1, 2, 5, 0, 0, 0, 0, 4, 4, 4, 4, 0,10,10, 0, 7, 0
|
||
|
||
; звуки
|
||
_count_sounds dd ?
|
||
_array_sounds rd 2*MAX_SOUNDS
|
||
|
||
_channel_sound_plane dd ? ; номер канала звука пропелера самолета
|
||
_channel_sound_arw dd ? ; номер канала звука сирены
|
||
_array_bombsoundchannels rd MAX_BOMBS ; массив номеров звуковых каналов для бомб
|
||
|
||
_set_volume dd 8 ; громкость 0..8
|
||
|
||
; разное
|
||
|
||
_s_current_dir rb 4096 ; путь к исполняемому файлу
|
||
|
||
file_info: ; информационная структура для работы с файлами
|
||
_fi_func dd ?
|
||
_fi_pos dd ?
|
||
dd 0
|
||
_fi_size dd ?
|
||
_fi_pbuff dd ?
|
||
db 0
|
||
_fi_pfilename dd ?
|
||
|
||
|
||
;include 'ruslang.inc'
|
||
include 'englang.inc'
|
||
|
||
bmp_plane:
|
||
file "plane.bmp":54
|
||
|
||
bmp_bomb:
|
||
file "bomb.bmp":54
|
||
|
||
bmp_tile:
|
||
file "tile.bmp":54
|
||
|
||
bmp_ackack:
|
||
file "ackack.bmp":54
|
||
|
||
|
||
align 16
|
||
rb 0x100 ; резерв памяти для стека.
|
||
|
||
i_end:
|
||
|