void kos_Main()
{
Dword frame_start, frame_end;
OnStart();
Menu();
for (;;)
{
frame_start = kos_GetTime();
switch (kos_CheckForEvent())
{
case 1:
DrawWindow();
break;
case 2: // key pressed, read it and ignore
Byte keyCode;
kos_GetKey(keyCode);
if (keyCode == 27)
{
OnExit();
}
break;
case 3: // button pressed; we have only one button, close
OnExit();
break;
case 6: // событие от мыши (нажатие на кнопку мыши или перемещение; сбрасывается при прочтении)
OnMouseMove();
if (ms.lbclick == 1)
{
OnLMBClick();
}
break;
default:
OnMouseMove();
break;
}
DrawBombs();
DrawRocketsAndCrosses();
DrawExplodes();
frame_end = kos_GetTime();
if (frame_end - frame_start < FRAME_TIME)
{
kos_Pause(FRAME_TIME - (frame_end - frame_start));
}
if (health <= 0)
{
OnExit();
}
}
}
void OnExit()
{
kos_WriteTextToWindow(WINDOW_WIDTH / 2 - 35, WINDOW_HEIGHT / 2 - 10, 0, TEXT_COLOR, "Game Over", 9);
//while(kos_WaitForEvent() != 2);
kos_Pause(200);
/*kos_DeleteMouseCursor(cur_handle);
for (int i = 0; i < R_COUNT; i++)
{
delete crosses[i];
delete rockets[i];
}
for (int i = 0; i < B_COUNT; i++)
{
delete bombs[i];
}
for (int i = 0; i < R_COUNT + B_COUNT; i++)
{
delete explodes[i];
}
delete[] crosses;
delete[] rockets;
delete[] bombs;
delete[] explodes;
delete gun;
delete house;
if (HARDWARE_CURSOR == 0)
{
delete cursor;
}*/
kos_ExitApp();
}
Byte *allocmem( Dword reqsize )
{
MemBlock *BlockForCheck;
MemBlock *LastKnownGood;
Dword tail;
Byte *address;
//подровняем размер
if( ( tail = reqsize % SIZE_ALIGN ) != 0 )
{
reqsize += SIZE_ALIGN - tail;
}
LastKnownGood = NULL;
// ждём освобождения мьютекса
while ( rtlInterlockedExchange( &mmMutex, TRUE ) )
{
//
kos_Pause( 1 );
}
//ищем подходящий свободный блок
if( rootfree != NULL )
{
for ( BlockForCheck = rootfree; ; BlockForCheck = BlockForCheck->Next )
{
if ( BlockForCheck->Size >= reqsize )
{
//нашли
if ( LastKnownGood != NULL )
{
if ( LastKnownGood->Size >= BlockForCheck->Size )
LastKnownGood = BlockForCheck;
}
else
LastKnownGood = BlockForCheck;
if ( LastKnownGood->Size == reqsize )
break;
}
if ( BlockForCheck->Next == NULL )
break;
}
}
if ( LastKnownGood != NULL )
{
//проверим найденный блок на возможность деления
tail = LastKnownGood->Size - reqsize;
if ( tail >= ( sizeof(MemBlock) + SIZE_ALIGN ) )
{
//будем разбивать
BlockForCheck = (MemBlock *)( ( (Byte *)LastKnownGood ) + tail );
BlockForCheck->Size = reqsize;
//вставим занятый блок в начало списка занатых блоков
if( rootuser != NULL )
{
BlockForCheck->Next = rootuser;
rootuser->Previous = BlockForCheck;
BlockForCheck->Previous = NULL;
rootuser = BlockForCheck;
}
else
{
rootuser = BlockForCheck;
BlockForCheck->Next = NULL;
BlockForCheck->Previous = NULL;
}
//изменим размер оставшейся части
LastKnownGood->Size = tail - sizeof(MemBlock);
address = ( (Byte *)BlockForCheck ) + sizeof(MemBlock);
// отпустим мьютекс
rtlInterlockedExchange( &mmMutex, FALSE );
return address;
}
else
{
//перемести блок из очереди свободных в начало очереди занятых
//сначала выкинем его из очереди свободных
if ( LastKnownGood->Previous != NULL )
{
LastKnownGood->Previous->Next = LastKnownGood->Next;
}
else
{
//блок стоит в начале очереди
rootfree = LastKnownGood->Next;
}
if( LastKnownGood->Next != NULL )
{
LastKnownGood->Next->Previous = LastKnownGood->Previous;
}
//теперь вставим его в очередь занятых
if( rootuser != NULL )
{
LastKnownGood->Next = rootuser;
rootuser->Previous = LastKnownGood;
LastKnownGood->Previous = NULL;
rootuser = LastKnownGood;
}
else
{
rootuser = LastKnownGood;
LastKnownGood->Next = NULL;
LastKnownGood->Previous = NULL;
}
//
address = ( (Byte *)LastKnownGood ) + sizeof(MemBlock);
// отпустим мьютекс
rtlInterlockedExchange( &mmMutex, FALSE );
return address;
}
}
else
{
// надо получить ещё блок памяти
LastKnownGood = (MemBlock *)kos_malloc(
(reqsize > 0x10000 - sizeof(MemBlock)) ? (reqsize + sizeof(MemBlock)) : 0x10000);
if (LastKnownGood != NULL)
{
LastKnownGood->Size = reqsize;
// теперь вставим его в очередь занятых
LastKnownGood->Next = rootuser;
LastKnownGood->Previous = NULL;
if (rootuser != NULL)
rootuser->Previous = LastKnownGood;
rootuser = LastKnownGood;
// а также добавим хвост свежевыделенного большого блока в список свободных
if (reqsize < 0x10000 - sizeof(MemBlock))
{
MemBlock* free = (MemBlock*)((Byte*)LastKnownGood + sizeof(MemBlock) + reqsize);
free->Next = rootfree;
free->Previous = NULL;
if (rootfree != NULL)
rootfree->Previous = free;
rootfree = free;
}
address = (Byte*)LastKnownGood + sizeof(MemBlock);
// отпустим мьютекс
rtlInterlockedExchange(&mmMutex, FALSE);
return address;
}
}
// отпустим мьютекс
rtlInterlockedExchange( &mmMutex, FALSE );
//
rtlDebugOutString( "allocmem failed." );
kos_ExitApp();
//
return NULL;
}
Dword freemem( void *vaddress )
{
Dword result;
Byte *checknext, *address = (Byte *)vaddress;
// ждём освобождения мьютекса
while ( rtlInterlockedExchange( &mmMutex, TRUE ) )
{
//
kos_Pause( 1 );
}
MemBlock *released = (MemBlock *)( address - sizeof(MemBlock) );
result = released->Size;
//убираем блок из списка занятых
if ( released->Previous != NULL )
{
released->Previous->Next = released->Next;
}
else
{
rootuser = released->Next;
}
if ( released->Next != NULL )
{
released->Next->Previous = released->Previous;
}
//закинем теперь этот блок в список свободных
released->Next = rootfree;
released->Previous = NULL;
rootfree = released;
if ( released->Next != NULL )
{
released->Next->Previous = released;
}
//теперь поищем смежные свободные блоки
checknext = (Byte *)(rootfree) + ( rootfree->Size + sizeof(MemBlock) );
//
for ( released = rootfree->Next; released != NULL; released = released->Next )
{
if ( checknext == (Byte *)released )
{
//собираем блоки вместе
//сначала выкинем из очереди свободных
released->Previous->Next = released->Next;
if( released->Next != NULL )
{
released->Next->Previous = released->Previous;
}
//теперь увеличим размер корневого блока
rootfree->Size += released->Size + sizeof(MemBlock);
break;
}
}
//если надо, поищем блоки перед текщим.
checknext = (Byte *)(rootfree);
//
if ( released == NULL )
{
for ( released = rootfree->Next; released != NULL; released = released->Next )
{
if ( checknext == (Byte *)released + ( released->Size + sizeof(MemBlock) ) )
{
//собираем блоки вместе
//увеличим размер блока
released->Size += rootfree->Size + sizeof(MemBlock);
//теперь выкинем из очереди свободных
released->Previous->Next = released->Next;
if ( released->Next != NULL )
{
released->Next->Previous = released->Previous;
}
//и закинем его в начало очереди вместо присоединённого блока из корня списка
if ( rootfree->Next != NULL )
{
rootfree->Next->Previous = released;
}
released->Next = rootfree->Next;
released->Previous = NULL;
rootfree = released;
break;
}
}
}
// отпустим мьютекс
rtlInterlockedExchange( &mmMutex, FALSE );
return result;
}
