format pe console 4.0

include 'win32ax.inc'
include 'api/kernel32.inc'

        INFINITE         EQU     0xFFFFFFFF
        GENERIC_LIFESPAN EQU     0xFA0 ; 4,000 Milliseconds
entry main

.data
    notify_produce    db  '*A new cell with DNA code: [0x%x] has been produced by parent cell with DNA code: [0x%x]',10,10\
                         ,'Cell with DNA code: [0x%x] has children: %u.',10,10,0

    notify_Population db 'There is now a total of %u cell(s).',10,10,0

    notify_death      db 'Cell with DNA code 0x%x has died, Sad news !',10,13,0
    cell_age dd 0
    cell_stage dd 1;  stages are 1 to 6
    msg_0 DB 'This is a simple implementation of a biological virus cell.'\
             ,10,10,'This virus cell will grow and produce other viruses as it grows.'\
             ,10,10,'It will reproduce at a certain age and also die at a certain age.'\
             ,10,10,'+----------------------------------------------------------------+'\
             ,13,10,'|Created by typedef - 2011                                       |'\
             ,10,'+----------------------------------------------------------------+',13,10,10,0

    ;Create a structure holding the cell's info
    struct CELL
           dwDNA       dd ? ; DNA of the cell
           dwAge       dd ? ; How long has the cell lived ? Maximum age is 4 Minutes old
           dwChildren  dd ? ; How many cells has this 'mother-cell' reproduced ? Will alway end up to be 1 
           dwTimeStamp dd ? ; When did it first come into existence (Calculated in Minutes)
           hHandle     dd ? ; Just a handle for destroying it so it doesn't clutter up in the system.
           dwCelliD    dd ? ; Will contain system thread id. This thread's ID, the child one will be dwDNA

    ends

           dwCellPop   dd 0 ; Cell population; Static data member

 cellParent CELL 0,0,0,0,0  ; Initialize first
 cellTemp   CELL

.code
    proc main
     invoke SetConsoleTitle,'A biological virus cell implementation'
     cinvoke printf,msg_0
     mov     [cellParent.dwAge],1       ; Increase every 1000 Milliseconds
     INC     [dwCellPop]
     MOV     [cellParent.dwTimeStamp],1  ; If timestamp

     ; Create the parent cell
     push   cellParent.dwDNA
     push   0
     push   cellParent         ;Pass this cell's instance as a parameter
     push   The_Life_Of_A_Cell ;Give it a life (LOL, a life, atleast I have a life, and I have given a life to a thing)
     push   0
     push   0
     call   [CreateThread]

     mov    [cellParent.hHandle],eax

     XOR    EAX,EAX

     call   [GetCurrentThreadId]

     MOV    [cellParent.dwCelliD],EAX
     ; Now what, hmmmmm..... Wait for the cell, right ?
     ;ok
     invoke WaitForSingleObject,[cellParent.hHandle],INFINITE
.Not_Done:
            CMP EAX,WAIT_OBJECT_0

            JNE .Not_Done
            cinvoke  printf,'The virus ecosystem doesn''t exist anymore. Sad Huh ?'

     invoke system,'pause'
     ;The_Life_Of_A_Cell

     push eax
     call [ExitProcess]
    endp
;
;
; This procedure creates another cell from the given cells DNA and ID
;
  proc  Make_Another_Cell_From_Cell
        PUSH ESP
        MOV  EBX,[ESP+4]

        MOV  EAX,[ESP+CELL.dwCelliD]

        MOV [cellTemp.dwCelliD],EAX
        MOV [cellTemp.dwDNA],0
        MOV [cellTemp.dwChildren],0
        MOV [cellTemp.dwTimeStamp],1
        MOV [cellTemp.hHandle],0
        MOV [cellTemp.dwAge],1

        invoke CreateThread,0,0,The_Life_Of_A_Cell,cellTemp,0,[cellTemp.dwDNA]
        MOV    [cellTemp.hHandle],EAX

        cinvoke WaitForSingleObject,EAX,INFINITE

        POP ESP
      ret

  endp
;As this program is the grand / mother of all cell's. It will create it's first child here
proc Cell_Reproduce ; void Cell_Reproduce(CELL *lpCell);
     PUSH ESP
     MOV  EBX,[ESP+8]

          ccall Make_Another_Cell_From_Cell,EBX

          ;;;cinvoke printf,notify_death,[EBX+CELL.dwAge] this was here for testing, Jeez leave me alone 
     POP  ESP
    ret
endp
;
;
;
proc Notify_Cell_Produced   ; VOID Notify_Cell_Produced (CELL *lpCell);
     PUSH ESP
               ;not done
     POP ESP
     ret
endp
;
;
; main cell Procedure
; This is the life of each cell. Each cell with have it's own image of this life
;
proc The_Life_Of_A_Cell;, LPVOID:DWORD <------- save some bytes here 

     PUSH ESP

     MOV EBX,[ESP+8]
     ;Create a local variable pointing to this cell
     ; I was using EBP here, so It doesn't exist anymore. You'll know what to do

     MOV EAX,[EBX+CELL.dwDNA]
     MOV ECX,[EBX+CELL.dwChildren]

     INC [EBX+CELL.dwChildren]

     ;Print to screen the Cell's life data
     cinvoke printf,notify_produce,[EBX+CELL.dwCelliD],[EBX+CELL.dwDNA],[EBX+CELL.dwDNA],[EBX+CELL.dwChildren]
     MOV     EAX,[dwCellPop]
     ADD     EAX,[EBX+CELL.dwChildren]
     MOV     [dwCellPop],EAX
     cinvoke printf,notify_Population,[dwCellPop]

    ;Now, grow the cell up to four minutes, every second
.Grow_Cell:

     CMP   [EBX+CELL.dwAge], 120 ; 2minutes Is cell mature enough to reproduce ?  2 mins old yet ?
     JNE   .TooYoungOrTooOld

     ccall Cell_Reproduce,EBX

.TooYoungOrTooOld:

     CMP   [EBX+CELL.dwAge],GENERIC_LIFESPAN;  4 minutes, die mfkr die !! !!
     JGE   .Cell_Dies

     invoke     Sleep,1000 ;    Sleep for 1 second
     INC        [EBX+CELL.dwAge] ; aging ? every living thing grows, Hey :/
     JMP        .Grow_Cell

.Cell_Dies:
     ;cinvoke
     invoke    CloseHandle,[EBX+CELL.hHandle]
     invoke    TerminateThread,[EBX+CELL.dwDNA]
    ; ADD       ESP,4    ;Clear the previous 4 allocated bytes
    ; <----------- Again, I was using EBP previously so don't be like 'Uhhhg'
          POP ESP
     ret
endp

section '.idata' import data readable
        library kernel32,'kernel32.dll',\
                msvc  ,  'msvcrt.dll'
 import msvc,\
        system,'system',\
        printf,'printf'