Subversion Repositories Kolibri OS

;

;   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,'',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