;
; Phoenix Game. Based on ASCL Library
;
;**********************************************************************
use32
org 0x0
db 'MENUET01' ; 8 byte id
dd 0x01 ; header version
dd START ; start of code
dd IM_END ; size of image
dd I_END ; memory for app
dd I_END ; esp stack position
dd 0x0 , 0x0 ; I_Param , I_Icon
;**********************************************************************
include 'lang.inc' ; for SVN 'lang.inc'
include '../../../macros.inc' ; for SVN '..\..\..\macros.inc;'
include 'ascl.inc' ; main
include 'ascgl.inc' ; graphics
include 'ascpoal.inc' ; processing object array
include 'ascgml.inc' ; game library for collision detection
; debug flags
keyboard_debug=0 ; Set to 1 to view all keyboard keys state in game
light_space=0 ; May used for check canvas position in window
debug_scenario=0 ; May used for fast test of gameplay
stack_leak_debug=0 ; Show stack size on screen
debug_mode=1 ; Support keys:
; A - set player hp = 10000. Make player ship undestructible
; E - player hp / 2
; W - view final screen after game begin
screen_w equ 640
screen_h equ 440
;screen_w equ 1014
;screen_h equ 739
; Define special colors
cl_DarkRed equ 0x990000
cl_Orange equ 0xbbbb00
; Define objects type id
EmptyObject equ 0
; This numbers not possible for modify because draw_objects:
BlueWarShip equ 1
GreenWarShip equ 2
Asteroid equ 3
Box equ 4
Laser equ 1
Plasma equ 2
StaticPlasma equ 3
;**************************************************************
; Start of programm
;**************************************************************
START: ; start of execution
max_particles = 400
particle_size = 20
mov [particles],dword max_particles
mov [particles+4],dword particle_size
max_objects = 100
object_size = 20
mov [objects],dword max_objects
mov [objects+4],dword object_size
keyboard_set_input_mode 1 ; 0 - ASCII; 1 - scancodes;
;giftoimg gif_file_area2,canvas
giftoimg gif_file_area,objects_image
; load sprites
mov cl,9 ; cl - counter
xor esi,esi ; esi = 0
lea edi,[ship_img] ; address of first sprite
load_sprite:
pushad
getimg objects_image,esi,0,32,32,edi
popad
add edi,8+32*32*3 ; incrase offest of image data
add esi,32 ; incrase x position
dec cl
jnz load_sprite
set_main_menu:
mov ebx,-1 ; at start event_mode = -1
lea ecx,[draw_main_window]
lea edx,[menu_keyboard]
set_draw_proc:
; assembler extract command ; for use only bl
mov [event_mode],ebx
mov [draw_proc],ecx
mov [keyboard_proc],edx
; at first draw window
main_menu:
redraw_event: ; redraw event appears if user move, show/hide window
call draw_window
no_event:
call [draw_proc] ; no event no requre draw_window for no flickering
if stack_leak_debug = 1
; stack memory leak debug
lea ebp,[I_END]
sub ebp,esp
outcount ebp,10,30,cl_Green,5*65536
end if
menu_loop:
;wait_event redraw_event,keyboard_event,button_event
mov eax,10 ; wait event
mov ebx,[event_mode]
cmp ebx,-1 ; ebx delay for mcall 23
je wait_ev
mov eax,23 ; time event
wait_ev:
mcall
dec eax
js no_event
jz redraw_event
dec eax
jz keyboard_event
dec eax
jz button_event
jmp menu_loop ; if unknown event, skip it
keyboard_event: ; keyboard event if user press button
call [keyboard_proc]
jmp menu_loop
button_event:
window_get_button
cmp ah,1 ; if button id=1 (Red X of window) then close app
je close_app
cmp ah,2 ; if button id=2 then close app
je close_app
cmp ah,3 ; if button id=3 then start game
je start_game
cmp ah,4 ; if button id=3 then show help menu
je set_help_window ; jmp with redraw window
cmp ah,5 ; if button id=5 then back to main menu
je set_main_menu ; jmp with redraw window
cmp ah,6
je next_level ; run next level
cmp ah,7
je restart_lev ; restart level from gameover
cmp ah,9
je set_game_window ; back to game from menu
jmp menu_loop
close_app:
mov eax,-1 ; close this program
mcall
menu_keyboard:
; nothing do
window_get_key
ret
;***********************
; Main screen menu
;***********************
draw_main_window:
draw_label 160,160,'Phoenix',cl_Red+font_size_x8
draw_button 3,300,320,60,14,'START',cl_DarkRed,cl_Yellow
draw_button 4,300,340,60,14,'HELP',cl_DarkRed,cl_Yellow
draw_button 2,300,360,60,14,'EXIT',cl_DarkRed,cl_Yellow
ret
;**********************
; End level process
;**********************
set_end_level_window_from_call:
add esp,4 ; remove call address from stack
set_end_level_window:
lea edx,[menu_keyboard]
mov ebx,-1
lea ecx,[draw_end_level_window]
jmp set_draw_proc
draw_end_level_window:
draw_frect 170,130,300,190,cl_Grey
draw_label 280,150,'LEVEL COMPLETE',cl_Black
draw_button 2,180,300,80,14,'EXIT',cl_DarkRed,cl_Black
draw_button 5,280,300,80,14,'<MENU>',cl_DarkRed,cl_Black
draw_button 6,380,300,80,14,'NEXT >',cl_DarkRed,cl_Black
draw_image 180,170,bwarship_img
draw_number [bships_destroyed],240,185,cl_Blue,3*65536
draw_image 180,210,gwarship_img
draw_number [gships_destroyed],240,225,cl_Green,3*65536
draw_image 180,250,box_img
draw_number [boxes_taken],240,265,cl_Orange,3*65536
ret
;**********************
; Game Over process
;**********************
restart_lev:
mov [next_wave_timer],0 ; Reset new wave timer
prevpart:
call get_wave_info_offset
xor eax,eax
mov ax,[ebp]
dec eax ; If eax = 0 then start of level finded
jz reset_all_varibles_and_restart_level
dec [level_wave]
jmp prevpart
set_game_over_window_from_call:
add esp,4
set_game_over_window:
lea edx,[menu_keyboard]
mov ebx,-1
lea ecx,[draw_game_over_window]
jmp set_draw_proc
draw_game_over_window:
draw_frect 170,160,300,120,cl_Grey
draw_label 292,200,'GAME OVER',cl_Black
draw_button 2,180,260,80,14,'EXIT',cl_DarkRed,cl_Black
draw_button 5,280,260,80,14,'MENU',cl_DarkRed,cl_Black
draw_button 7,380,260,80,14,'RESTART',cl_DarkRed,cl_Black
ret
;***********************
; Main game loop
;***********************
next_level:
mov [next_wave_timer],0 ; Reset next wave timer
inc [level_wave] ; Next wave
start_game:
; Set canvas size before logo is showed
image_set_size canvas,screen_w,screen_h
; Clear all, and prepeare varibles before start
reset_all_varibles_and_restart_level:
; Clear objects arrays
mov eax,0
cld
mov edi,particles+8
mov ecx,max_particles*particle_size/4
rep stosd
mov edi,objects+8
mov ecx,max_objects*object_size/4
rep stosd
; Reset keyboard state array
clear_buffer keymap, 128, 0
; Reset player ship state
mov [player_hp],100
mov [shipx],screen_w/2-16 ; Player ship x start position
mov [shipy],screen_h-40 ; Player ship y start position
mov [laser_shoots],1000 ; Laser projectiles at start
mov [plasma_shoots],500 ; Plasma projectiles at start
; Reset counters and gun charge values
xor eax,eax
mov [boxes_taken],eax
mov [gships_destroyed],eax
mov [bships_destroyed],eax
mov [laser_charge],eax
mov [plasma_charge],eax
set_game_window:
lea edx,[ingame_keyboard]
lea ecx,[draw_game_window]
mov ebx,2 ; time_event ebx = 2 ms
jmp set_draw_proc
draw_game_window:
draw_image 5,24,canvas
xor eax,eax ; Use eax as zero for compare
cmp [pause_on],eax ; If pause = 0 nothing do
je no_pause
ret
no_pause:
cmp [player_hp],eax ; If player_hp < 0 game over
jl set_game_over_window_from_call
cmp [laser_charge],eax
je no_dec_laser_charge
dec dword [laser_charge] ; If laser_charge > 0 decrase it
no_dec_laser_charge:
cmp [plasma_charge],eax
je no_dec_plasma_charge
dec dword [plasma_charge] ; If plasma_charge > 0 decrase it
no_dec_plasma_charge:
; new wave test
inc dword [next_wave_timer]
call get_wave_info_offset
mov ax,[ebp] ; [ebp] = time to activate string
cwde ; extend ax to eax
cmp [next_wave_timer],eax
jne no_next_wave
add_new_wave_of_objects:
mov cl,[ebp+4+0] ; cl = count of ships
mov ch,GreenWarShip ; ch = type of object
mov ebx,0x09040302 ; ebx = [xmoving]:[xaccel]:[ymoving]:[yaccel]
call add_objects ; add objects
mov cl,[ebp+4+1] ; cl = count of ships
mov ch,BlueWarShip ; ch = type of object
mov ebx,0x03010306 ; ebx = random ranges : x = -1..1 y = -6..-4
call add_objects ; add objects
mov cl,[ebp+4+2] ; cl = count of asteroids
mov ch,Asteroid ; ch = type of object
mov ebx,0x05020502 ; ebx = [xmoving]:[xaccel]:[ymoving]:[yaccel]
call add_objects ; add objects
mov cl,[ebp+4+3] ; cl = count of boxes
mov ch,Box ; ch = type of object
mov ebx,0x05020401 ; ebx = [xmoving]:[xaccel]:[ymoving]:[yaccel]
call add_objects ; add objects
mov [next_wave_timer],0 ; Reset next wave timer
inc [level_wave] ; Next wave
no_next_wave:
; Calculate all active objects on screen
xor eax,eax ; Use eax as zero
mov [objects_num],eax
array_processing objects,endtest ; ar_proc not modify eax, ebx
xor eax,eax ; Use eax as zero
cmp [objects_num],eax ; If [objects_num] != 0, level is not complete
jnz level_not_complete
call get_wave_info_offset
mov ax,[ebp+2] ; ax = maxyrange
cwde ; extend ax to eax
xor ebx,ebx ; Use ebx as zero for compare
cmp eax,ebx ; If [ebp+2] of level = 0, this is end of level
je set_end_level_window_from_call ; Show player score
dec ebx ; Use ebx as -1 for compare
cmp eax,ebx
je set_final_screen_window_from_call ; Show final animation
level_not_complete:
no_end_lev:
; Key state processing
cmp byte [keymap+key_Right],0
je no_key_right
add dword [shipx],6
no_key_right:
cmp byte [keymap+key_Left],0
je no_key_left
sub dword [shipx],6
no_key_left:
cmp byte [keymap+key_Space],0
je no_key_lshoot
call try_to_make_laser_shoot
;call try_to_make_plasma_shoot
no_key_lshoot:
cmp byte [keymap+key_Up],0
je no_key_pshoot
;call try_to_make_plasma_nuke
call try_to_make_plasma_shoot
no_key_pshoot:
cmp byte [keymap+key_Down],0
je no_key_pnuke
call try_to_make_plasma_nuke
;call try_to_make_laser_shoot
no_key_pnuke:
; Ship position correction (clamp macro)
cmp [shipx],5
jnl @f
mov [shipx],5
@@:
cmp [shipx],screen_w-32-5
jng @f
mov [shipx],screen_w-32-5
@@:
mov al,7
if light_space = 1
mov al,255
end if
clear_buffer canvas+8,canvas_end-canvas-8,al
compmas objects,particles,objects_and_particles_hit_handling
; move objects and particles
array_processing objects,move_objects
array_processing particles,move_particles
; remove particles out of screen
array_processing particles,remove_outofscr_particles
; objects and particles collision test
array_processing objects,player_and_objects_collision_handling
array_processing particles,player_and_particles_collision_handling
; draw objects and particles
array_processing objects,draw_objects
array_processing particles,draw_particles
; draw player ship
image_draw_acimage canvas,ship_img,[shipx],[shipy],cl_Black
; Draw info indicators
draw_frect 150,5,64,5,cl_Black
mov eax,[plasma_charge]
sub eax,256
neg eax
shr eax,2
draw_frect 150,5,eax,5,cl_Cyan
draw_frect 150,12,64,5,cl_Black
mov eax,[laser_charge]
sub eax,8
neg eax
shl eax,3
draw_frect 150,12,eax,5,cl_Yellow
draw_frect 220,2,6*5+2 ,9,cl_Grey
draw_number [plasma_shoots],221,3,cl_Cyan,5*65536
draw_frect 220,11,6*5+2 ,9,cl_Grey
draw_number [laser_shoots],221,12,cl_Yellow,5*65536
draw_frect 280,6,6*5+2 ,9,cl_Grey
draw_number [gships_destroyed],281,7,cl_Green,5*65536
draw_frect 320,6,6*5+2 ,9,cl_Grey
draw_number [bships_destroyed],321,7,cl_Blue,5*65536
draw_frect 360,6,6*5+2 ,9,cl_Grey
draw_number [boxes_taken],361,7,0xffaa00,5*65536
; number of objects in scene
draw_frect 400,2,6*5+2 ,9,cl_Grey
draw_number [objects_num],401,2,cl_Lime,5*65536
draw_frect 400,11,6*5+2 ,9,cl_Grey
draw_number [player_hp],401,12,cl_Red,5*65536
draw_frect 450,11,6*5+2 ,9,cl_Grey
draw_number [score],451,12,cl_Yellow,5*65536 ;+hide_zeros
; print keyboard keys state as string for debug
if keyboard_debug = 1
mov ebx,10*65536+40
mov edx,keymap
mov esi,128
mov ecx,cl_White
mov eax,4
mcall
end if
ret
; Proc for calculate active objects on screen
; eax - empty object type = 0
endtest:
xor eax,eax
cmp dword [edi+8],eax ; object is empty ?
je is_free
inc [objects_num]
is_free:
ret
; Proc for get offest to current level wave information
get_wave_info_offset:
mov ebp,[level_wave]
shl ebp,3 ; ebp = ebp*8; 8 - lenght of one string in levels array
add ebp,levels ; ebp = offset to string in levels array
ret
; time_bwns - time before next wave start
; yrmax - y random position maximum value
macro objects_wave time_bnws, yrmax, gships, bships, asteroids, boxes{
dw time_bnws, yrmax
db gships, bships, asteroids, boxes
}
level_wave dd 0
; this array may optimized
levels:
; for game not ended at start, each level must have objects set at start (1)
; test pattern
if debug_scenario = 1
; two levels for debug game
objects_wave 1, 10, 1, 2, 4, 8 ; objset at start
objects_wave 0, 0, 0, 0, 0, 0
objects_wave 1, 10, 3, 3, 3, 3 ; objset at start
objects_wave 0, -1, 0, 0, 0, 0
else
; level 1
objects_wave 1, 4000, 3, 10, 10, 0 ; objset at start
objects_wave 800, 2000, 5, 3, 5, 3
objects_wave 400, 2000, 3, 7, 5, 3
objects_wave 400, 800, 3, 5, 3, 0
objects_wave 0, 0, 0, 0, 0, 0 ; end of level
; level 2
objects_wave 1, 4000, 10, 40, 0, 8 ; objset at start
objects_wave 400, 4000, 10, 10, 20, 6
objects_wave 400, 2000, 0, 20, 10, 2
objects_wave 400, 400, 10, 10, 20, 0
objects_wave 0, 0, 0, 0, 0, 0 ; end of game
; level 3
objects_wave 1, 800, 0, 0, 5, 5 ; objset at start
objects_wave 500, 2000, 4, 20, 30, 0
objects_wave 500, 2000, 4, 20, 0, 8
objects_wave 500, 2000, 10, 0, 0, 4
objects_wave 500, 4000, 0, 30, 0, 0
objects_wave 400, 400, 3, 5, 15, 0
objects_wave 400, 400, 0, 0, 10, 0
objects_wave 0, -1, 0, 0, 0, 0 ; end of level
end if
;***********************************
; In game keyboard
;***********************************
ingame_keyboard:
window_get_key ; read key (eax=2)
cmp al,0
jne this_is_hotkey
; ah - contain scan code, al = 0
shl eax,16
shr eax,24 ; equal shr eax,8 + and eax,0x0FF
; eax - contain scan code
cmp al,key_P+128
jne not_P_key_up_scan_code
not [pause_on]
not_P_key_up_scan_code:
if debug_mode = 1
cmp al,key_E ; player hp = player hp / 2
jne no_hp_test
shr [player_hp],1
no_hp_test:
cmp al,key_A ; player hp = 10000
jne no_hp_up
mov [player_hp],10000
no_hp_up:
cmp al,key_W ; Run final screen
je set_final_screen_window_from_call
end if
; Keyboard array update, needs sub state
cmp al,01111111b
ja key_released
mov byte [keymap+eax],'1' ; If scan code of key down
jmp key_pressed
key_released:
and al,01111111b
mov byte [keymap+eax],0 ; If scan code of key up
key_pressed:
this_is_hotkey:
ret
;**********************
; Final screen process
;**********************
set_final_screen_window_from_call:
add esp,4 ; Remove call address from stack
set_final_screen_window:
lea edx,[menu_keyboard]
mov ebx,1
lea ecx,[draw_final_screen_window]
jmp set_draw_proc
you_won_text: db 'YOU WON!',0
draw_final_screen_window:
draw_image 5,24,canvas
logo_font_size equ 5
logo_x = 5+(screen_w/2)-(6*logo_font_size*8/2)
logo_y = screen_h/16*5
draw_label logo_x,logo_y,you_won_text,cl_White+((logo_font_size-1) shl 24)
;image_draw_label canvas,200,8,'YOU WON!',cl_White
draw_button 5,(screen_w/2)-40+5,300,80,14,'BACK TO MENU',cl_DarkRed,cl_Black
clear_buffer canvas+8,canvas_end-canvas-8,7
image_draw_acimage canvas,ship_img,(screen_w/2)-16,220,cl_Black
array_processing particles,draw_particles
array_processing particles,move_particles ; move particles
array_processing particles,remove_outofscr_particles ; del_outscreen_particles
try_to_make_firework:
inc [next_wave_timer]
cmp [next_wave_timer],30
jna no_firework
mov [next_wave_timer],0 ; reset firework timer before make firework
random screen_w-60,eax
mov ebx,eax
random screen_h-60,eax
mov edx,eax
mov ecx,8 ; how much particles make in one fire explode
next_star:
array_find particles,find_empty_object
jc close_app
mov [edi],ebx ; random x position
mov [edi+4],edx ; random y position
mov [edi+8],dword 3 ; type of partice = 3. final screen particle
rerand:
random 5,eax
sub eax,2
jz rerand ; eax = -2...2 exclude 0
mov [edi+12],eax ; x velocity
rerand2:
random 7,eax
sub eax,3
jz rerand2 ; eax = -3...3 exclude 0
mov [edi+16],eax ; y velocity
dec ecx
jnz next_star
no_firework:
ret
;***********************
; Help menu
;***********************
set_help_window:
lea edx,[menu_keyboard]
mov ebx,-1
lea ecx,[draw_help_window]
jmp set_draw_proc
draw_help_window:
; draw background and gray rectangle for label
;draw_frect canvas size cl_Black
draw_frect 40,50,580,380,cl_Grey
; draw labels
mov ebp,4*7+3 ; Set value to labels counter
mov ebx,180*65536+90
mov edx,helptext
mov esi,50
mov ecx,cl_White+(10000000b shl 24)
draw_next_string:
mov eax,4
mcall ; Draw label
@@:
mov al,[edx] ; Loop for find next zero
inc edx
cmp al,0
jne @b
add ebx,10 ; Incrase y position of label
dec ebp ; Decrase labels counter
jnz draw_next_string
; draw images of space objects
mov eax,90
mov ecx,7
@@:
mov esi,[(img_offset-4)+ecx*4]
pushad
draw_image 90,eax,esi
popad
add eax,40
dec ecx
jnz @b
draw_button 5,500,400,80,14,'< BACK',cl_DarkRed,cl_Black
ret
; Offset to images showed in help screen in reverse sequence
img_offset:
dd box_img,asteroid_img,gwarship_img,bwarship_img
dd plasma1_img,laser_img,ship_img
helptext:
db 'Phoenix - player ship',0
db 'Controls:',0
db 'Left or Right Arrows for move ship, P - button for pause',0
db 0
db 'Laser gun',0
db 'Recharge fast, speed fast. Projectile speed is medium',0
db 'Press Space button for shoot',0
db 0
db 'Plasma gun',0
db 'Recharge slow, reload fast. Projectile speed is fast',0
db 'Press Up button for shoot or Down button for make Nuke',0
db 0
db 'Blue warship',0
db 'Moving speed is fast',0
db 'Armed with plasma bombs',0
db 0
db 'Green warship',0
db 'Moving speed is medium',0
db 'Armed with laser gun',0
db 0
db 'Asteroid',0
db 'Is not destructable dangeros object!',0
db 'Collision with asteroid damage ship to much',0
db 0
db 'Repear Box',0
db 'Shield pack. Shield +5, Score +30',0
db 'Take on board for shield level up!',0
db 0,0,0
db 'Developed by Pavlushin Evgeni 2004',0
; ****************************************
; GLOBAL DRAW WINDOW
; ****************************************
draw_window:
window_begin_draw
mcall 0, <40, screen_w+9>, <40, screen_h+24+4>, 0x14000000,, wtitle
window_end_draw
ret
; ****************************************
; GAME PROCEDURE AREA
; ****************************************
; Procedure for add ships to scene
; cl - number of ships which need to add 0..255
; ebp - offset to level string
add_objects:
; unpack values from ebx
xor eax,eax
mov al,ch
mov [shiptype],eax
mov al,bl
mov [yaccel],eax
mov al,bh
mov [ymoving],eax
shr ebx,16
mov al,bl
mov [xaccel],eax
mov al,bh
mov [xmoving],eax
next_ship:
cmp cl,0
je no_ships ; if ships quantity = 0, exit from proc
push ecx
push ebp
; find empty slot in space objects array
array_find objects,find_empty_object
jc close_app
; edi = offset to empty place in array
mov eax,[shiptype]
mov dword [edi+8],eax ; store ship type
; Randomize x position
random screen_w-32,eax
mov [edi],eax
; Randomize y position
pop ebp
mov ax,[ebp+2] ; get max range
cwde ; extend ax to eax
random eax,eax
neg eax
mov [edi+4],eax
; Randomize x moving
random [xmoving],eax
sub eax,[xaccel]
mov [edi+12],eax
; Randomize y moving
random [ymoving],eax
add eax,[yaccel]
mov [edi+16],eax
pop ecx
dec cl
jnz next_ship
no_ships:
ret
; search empty slot in object array
find_empty_object:
cmp [edi+8],dword 0 ; if object type == 0 then it empty
je is_finded ; empty object is finded set CF = 0
; find_next
stc ; CF = 1
ret
is_finded:
clc ; CF = 0
ret
; Try to draw particle from particle array
draw_particles:
mov ecx,[edi+8] ; ecx - type of particle
cmp ecx,0 ; if type == 0 then do not draw object
je return
mov eax,laser_img
cmp ecx,Laser ; this is laser particle
je draw_space_object
mov eax,plasma2_img
cmp ecx,StaticPlasma ; particle type for final screen animation
je draw_space_object
random 3,ebx ; if else this is Plasma particle
mov eax,plasma1_img
dec ebx
jz draw_space_object
mov eax,plasma2_img
dec ebx
jz draw_space_object
mov eax,plasma3_img
jmp draw_space_object
; Draw space objects from array
draw_objects:
mov ecx,[edi+8] ; ecx = [edi+8] - type of ship
cmp ecx,0 ; if type of ship == 0 then not draw it
je return
cmp ecx,(ot_end-object_type)/4+1
jae return ; if type out of range ignore it
mov edx,[edi+4] ; edx = [edi+4] - y position of ship
cmp edx,screen_h-40
jg return
cmp edx,0 ; do not draw object if it y position is out of screen
jl return
mov eax,[(object_type-4)+ecx*4] ; -4 when types starts from 1 instead 0
draw_space_object:
image_draw_acimage canvas,eax,dword [edi],dword [edi+4],cl_Black
return:
ret
object_type: dd bwarship_img,gwarship_img,asteroid_img,box_img
ot_end:
; Update (move) particles (laser,plasma)
move_particles:
xor eax,eax
cmp [edi+8],eax ; Is object not empty ?
je this_is_empty_particle
move_particle:
mov eax,[edi+12]
add [edi],eax ; objectx + [edi+12]
mov eax,[edi+16]
add [edi+4],eax ; objecty + [edi+16]
this_is_empty_particle:
ret
; update (move) space objects (ships,asteroids,boxes)
move_objects:
xor eax,eax
cmp [edi+8],eax
je object_is_empty
;call move_particle
mov eax,[edi+12]
add [edi],eax
mov eax,[edi+16]
add [edi+4],eax
; Do not allow object to go out of screen from right side
mov eax,screen_w-32 ; eax = right side of screen
cmp dword [edi],eax
jng right_side_ok
mov dword [edi],eax
neg dword [edi+12]
jmp left_side_ok
right_side_ok:
; Do not allow object to go out of screen from left side
xor eax,eax ; eax = 0 - left side of screen
cmp dword [edi],eax
jnl left_side_ok
mov dword [edi],eax
neg dword [edi+12]
left_side_ok:
; If object out of screen remove it
cmp dword [edi+4],screen_h;-40
jng y_ok
mov dword [edi+8],0 ; Delete object
ret
y_ok:
cmp dword [edi+8],GreenWarShip ; Object is green enemy ship?
jne no_grs
mov eax,dword [edi+4] ; eax = y position of enemy ship
; alternative way is use random for shoot
cmp eax,100
jna no_grs
cmp eax,103
jna grs
cmp eax,200
jna no_grs
cmp eax,203
jna grs
cmp eax,300
jna no_grs
cmp eax,303
ja no_grs
grs:
; invert y moving direction and make shoot
neg dword [edi+12]
mov [temp],edi
array_find particles,find_empty_object
jc close_app
mov esi,[temp] ; edi contains address to free element
mov [edi+8],dword 1
mov [edi+12],dword 0
mov [edi+16],dword 10
jmp set_particle_position
no_grs:
cmp dword [edi+8],BlueWarShip ; object is blue enemy ship ?
jne no_bls
mov ecx,dword [edi+4]
cmp ecx,50
jna no_bls
cmp ecx,64
jna bls
cmp ecx,100
jna no_bls
cmp ecx,114
jna bls
cmp ecx,150
jna no_bls
cmp ecx,164
ja no_bls
bls:
; drop plasma mine
mov [temp],edi
array_find particles,find_empty_object
jc close_app
mov esi,[temp]
mov [edi+8],dword 2
mov [edi+12],dword 0
mov [edi+16],dword 5
set_particle_position:
mov eax,[esi]
mov [edi],eax ; Particle x = Ship x
mov eax,[esi+4]
mov [edi+4],eax ; Partcle y = Ship y
no_bls:
object_is_empty:
ret
; Remove particles that have gone out off screen
remove_outofscr_particles:
cmp dword [edi+4],40 ; test y position
jl del
cmp dword [edi+4],screen_h-40
jg del
cmp dword [edi],0 ; x test used for plasma shoots
jl del
cmp dword [edi],screen_w-32
jg del
ret ; do not delete
del:
xor eax,eax
mov [edi+8],eax ; [edi+8] = 0
not_del:
ret
objects_and_particles_hit_handling:
xor eax,eax
cmp [esi+8],eax
je no_hit
cmp [edi+8],eax ; If object is empty skip crush test
je no_hit
cmp [esi+16],eax
jg no_hit
mov eax,[esi]
shl eax,16
mov ax,word [esi+4]
mov ebx,32*65536+32
mov ecx,[edi]
shl ecx,16
mov cx,word [edi+4]
mov edx,32*65536+32
game_collision_2d eax,ebx,ecx,edx
jnc no_hit
cmp dword [edi+8],GreenWarShip
jne not_grship
inc [gships_destroyed]
add [score],30
jmp remove_object_and_particle
not_grship:
cmp dword [edi+8],BlueWarShip
jne not_blship
inc [bships_destroyed]
add [score],20
jmp remove_object_and_particle
not_blship:
cmp dword [edi+8],Asteroid
jne not_asteroid
cmp dword [edi+16],1 ; Asteroid have minimal speed?
je remove_only_particle
dec dword [edi+16] ; Decrase speed of asteroid
jmp remove_only_particle
not_asteroid:
remove_object_and_particle: ; When hit to ship or box
mov [edi+8],dword 0
remove_only_particle: ; When hit to asteroid
mov [esi+8],dword 0
no_hit:
ret
player_and_objects_collision_handling:
cmp [edi+8],dword 0
je no_obj_cr
mov eax,[shipx]
shl eax,16
mov ax,word [shipy]
mov ebx,32*65536+32
mov ecx,[edi]
shl ecx,16
mov cx,word [edi+4]
mov edx,32*65536+32
game_collision_2d eax,ebx,ecx,edx
jnc no_obj_cr
cmp dword [edi+8],Box ; if box
jne no_fbox
add [player_hp],5
add [score],50
mov [edi+8],dword 0 ; delete object
inc [boxes_taken]
ret
no_fbox:
sub [player_hp],16
mov [edi+8],dword 0 ; delete object
no_obj_cr:
ret
player_and_particles_collision_handling:
xor eax,eax ; use eax as zero
cmp [edi+8],eax ; empty object?
je no_gobj_cr
cmp [edi+16],eax ; is player ?
jl no_gobj_cr
mov eax,[shipx]
shl eax,16
mov ax,word [shipy]
mov ebx,32*65536+32
mov ecx,[edi]
shl ecx,16
mov cx,word [edi+4]
mov edx,32*65536+32
game_collision_2d eax,ebx,ecx,edx
jnc no_gobj_cr
sub [player_hp],4
mov [edi+8],dword 0 ; delete object
no_gobj_cr:
ret
;**************************
; Player ship shoot procs
;**************************
; Try to make laser shoot
try_to_make_laser_shoot:
cmp [laser_charge],dword 0
jne no_laser_shoot ; laser_shoots is heat, need time for recharge
cmp [laser_shoots],dword 0
je no_laser_shoot ; Don't shoot when so many laser particles on screen
array_find particles,find_empty_object ; edi = offset to emppty object
jc close_app ; ?
mov eax,[shipx]
mov [edi],eax ; 0 = x position of shoot
mov eax,[shipy]
mov [edi+4],eax ; 4 = y position of shoot
mov [edi+8],dword 1 ; 8 = 1 - laser type
mov [edi+12],dword 0 ; 12 = 0 - x speed
mov [edi+16],dword -12 ; 16 = -12 - y speed
mov [laser_charge],dword 8 ; Reset shoot timer
dec [laser_shoots] ; Decrase number of laser projectiles
no_laser_shoot:
ret
; Try to make plasma shoot
try_to_make_plasma_shoot:
cmp [plasma_charge],dword 256-16
jae no_plasma_shoot
cmp [plasma_shoots],0
je no_plasma_shoot
array_find particles,find_empty_object
; edi = off to free element
jc close_app ;?
mov eax,[shipx]
mov [edi],eax
mov eax,[shipy]
mov [edi+4],eax
mov [edi+8],dword 2 ; 8 = 2 - plasma
mov [edi+12],dword 0 ; 12 = 0 - x speed
mov [edi+16],dword -8 ; 16 = -8 - y speed
dec [plasma_shoots] ; Decrase number of plasma projectiles
add [plasma_charge],dword 8
cmp [plasma_charge],dword 256
jna no_plasma_shoot
mov [plasma_charge],256
no_plasma_shoot:
ret
; Try to make plasma nuke
try_to_make_plasma_nuke:
xor eax,eax ; Use eax as zero
cmp [plasma_charge],eax
jne no_plasma_nuke
cmp [plasma_shoots],eax
je no_plasma_nuke
mov eax,[shipy]
mov [temp3],eax
mov [temp2],dword 5
loopx2:
mov [temp],dword 10
loopx:
array_find particles,find_empty_object ; edi = offset to empty element
jc close_app
random 25,eax
mov ebp,eax
sub ebp,12
add ebp,[shipx]
mov [edi],ebp ; [edi] = random(0..25)-12+shipx
shr eax,3
random eax,eax
neg eax
add eax,[temp3]
mov [edi+4],eax
mov [edi+8],dword 2 ; 8 = 2 - plasma
random 5,eax
sub eax,2
mov [edi+12],eax
random 7,eax
sub eax,8
mov [edi+16],eax
dec [temp]
jnz loopx
sub [temp3],30 ; shipy - 30
dec [temp2]
jnz loopx2
mov [plasma_charge],dword 256 ; Wait for cannon
sub [plasma_shoots],50 ; -50 plasma bullets after nuke
no_plasma_nuke:
ret
; DATA AREA
IM_END:
wtitle db 'Phoenix for KOS', 0
score dd 0 ; player score
; Pause state, if != 0 then game on pause
pause_on dd 0
; Frames countdown timer until start of next wave
; If = 0 then activate to next wave
; next_wave_timer
next_wave_timer dd 0
;gif_file_area ~21500
;gif_file_area2:
;file 'phoenix.gif'
gif_file_area:
file 'objects.gif' ; Include gif file to code
IncludeUGlobals
; Window drawing function delegate (pointer)
draw_proc rd 1
; Keyboard processing function delegate (pointer)
keyboard_proc rd 1
; Counter of objects on screen
objects_num rd 1
player_hp rd 1 ; Health points of player ship
shipx rd 1 ; Player ship x position
shipy rd 1 ; Player ship y position
; guns
laser_shoots rd 1 ; laser bullets quantity
plasma_shoots rd 1 ; plasma bullets quantity
; Counters of player statistics
gships_destroyed rd 1 ; Number of green ships destroyed by player
bships_destroyed rd 1 ; Number of blue ships destroyed by player
boxes_taken rd 1 ; Number of repair boxes taken by player
; Gun recharge counters
; 0 = fully charged
; 256 = fully uncharged
laser_charge rd 1 ; Laser gun recharge counter
plasma_charge rd 1 ; Plasma gun recharge counter
; Tempory varibles
temp rd 1
temp2 rd 1
temp3 rd 1
event_mode rd 1 ; if -1 wait, 0 scan, n - n delay between events
; Tempory varibles for add_objects proc
shiptype rd 1
xmoving rd 1
ymoving rd 1
xaccel rd 1
yaccel rd 1
; Memory for contain not splitted image
objects_image: rb 8+288*32*3 ;8+256*64*3
; Images sequence extracted from objects_image
ship_img: rb 8+32*32*3 ; Player red space ship
laser_img: rb 8+32*32*3 ; Double laser beams
bwarship_img: rb 8+32*32*3 ; Blue enemy ship
gwarship_img: rb 8+32*32*3 ; Green enemy ship
asteroid_img: rb 8+32*32*3 ; Space asteroid
plasma1_img: rb 8+32*32*3 ; Plasma big flash
plasma2_img: rb 8+32*32*3 ; Plasma medium flash
plasma3_img: rb 8+32*32*3 ; Plasma small flash
box_img: rb 8+32*32*3 ; Repear kit box
; array for storing state of keyboard keys
keymap: rb 128
particles:
rd max_particles ; dword = maximum number of particle objects
rd particle_size ; dword = size of each particle object in bytes
rb max_particles*particle_size
objects:
rd max_objects ; dword = maximum number of particles
rd object_size ; dword = size of each object in bytes
rb max_objects*object_size
canvas:
rb 8+(screen_w*screen_h*3)
canvas_end:
; application stack size
align 16
stack_max:
rb 2048
I_END: