apps/floppybird: rewrite to c (#284)

What was done:
- [x] Rewritten to C
- [x] Refactored some code
- [x] Fixed window resizing (#182)
- [x] Adaptation for different skin height
- [x] Fixed some tubes leftovers drawing
- [x] Changed tubes generation a little bit
- [x] Changed interface a little bit
- [x] Added Escape key for exit to main menu
- [x] Removed buttons from main menu (hotkeys left) :(

What needs to be done:
- [ ] ~~Fix rolled-up bug?~~
- [ ] ~~Fit it into 2048 bytes?~~
- [ ] ~~Add pause?~~
- [ ] ~~Use buffer for drawing without flickering?~~

P.S. There is no way game with all this changes will fit in 2560 bytes, as previous version, so I decided to skip them.

Reviewed-on: KolibriOS/kolibrios#284
Reviewed-by: Ivan B <dunkaist@noreply.localhost>
Reviewed-by: Mikhail Frolov <mixa.frolov2003@gmail.com>
Co-authored-by: Burer <burer@kolibrios.org>
Co-committed-by: Burer <burer@kolibrios.org>
This commit is contained in:
Burer authored and Burer committed 2025-12-29 06:34:23 +00:00
1 parent bc5b2f884a
commit f4c4a7e29a
28 files changed
+464 -3364

No files matched your search

-7
View File
@@ -1,7 +0,0 @@
## Floppy Bird for KolibriOS
* [Forum topic](http://board.kolibrios.org/viewtopic.php?f=41&t=4471) <br>
* [Directory in official KolibriOS GIT repository] kolibrios\programs\games\floppybird
<img src="https://i.ibb.co/kMsv8pB/menu.jpg" alt="Screenshot" width="400"> <img src="https://i.ibb.co/7NP1yHZ/screen1.jpg" alt="Screenshot" width="400">
<img src="https://i.ibb.co/Y2FwxDG/screen2.jpg" alt="Screenshot" width="400"> <img src="https://i.ibb.co/3W8yCYn/gameover.jpg" alt="Screenshot" width="400">
Binary file not shown.
@@ -1,73 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{0556BA3E-9447-4000-8613-91AD1CD750D7}</ProjectGuid>
<RootNamespace>floppybird</RootNamespace>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<GenerateManifest>false</GenerateManifest>
<EmbedManifest>false</EmbedManifest>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>MinSpace</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<BufferSecurityCheck>false</BufferSecurityCheck>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<AdditionalIncludeDirectories>smalllibc</AdditionalIncludeDirectories>
<OmitFramePointers>true</OmitFramePointers>
<FavorSizeOrSpeed>Size</FavorSizeOrSpeed>
<RuntimeTypeInfo>false</RuntimeTypeInfo>
</ClCompile>
<Link>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<IgnoreAllDefaultLibraries>true</IgnoreAllDefaultLibraries>
<EntryPointSymbol>fakeEntry</EntryPointSymbol>
<SubSystem>Native</SubSystem>
<AdditionalOptions>/merge:.data=.text /merge:.rdata=.text /merge:.1seg=.text /section:.bss,E %(AdditionalOptions)</AdditionalOptions>
<GenerateMapFile>true</GenerateMapFile>
</Link>
<PostBuildEvent>
<Command>set EXENAME=$(TargetPath)
"C:\kolibri\fasm\FASM.EXE" $(ProjectDir)smalllibc\doexe2.asm $(TargetDir)$(TargetName)</Command>
</PostBuildEvent>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="floppybird.cpp" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="smalllibc\smalllibc.vcxproj">
<Project>{0D291390-1953-4E1F-BBE2-57F12AFF3214}</Project>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<ClInclude Include="images.hpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
@@ -1,27 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Файлы исходного кода">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Заголовочные файлы">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
<Filter Include="Файлы ресурсов">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="floppybird.cpp">
<Filter>Файлы исходного кода</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="images.hpp">
<Filter>Файлы исходного кода</Filter>
</ClInclude>
</ItemGroup>
</Project>
-436
View File
@@ -1,436 +0,0 @@
#include <kosSyst.h>
#include <kosFile.h>
#include "images.hpp"
//Global const strings
const char HEADER_STRING[] = "Floppy bird";
const char CONTROL_STRING[] = "SPACEBAR TO JUMP";
const char GAMEOVER_STRING[] = "GAMEOVER";
const char ANY_KEY_STRING[] = "Press any key for restart";
const char SELECT_SPEED_STRING[] = "select the speed of the game";
const char FAST_STRING[] = "1 FAST";
const char SLOW_STRING[] = "2 SLOW";
//Global const variables
const int WINDOW_WIDTH = 400;
const int WINDOW_HEIGHT = 400;
const int BORDER_TOP = 24;
const int BORDER_LEFT = 5;
const int BORDER_RIGHT = 5;
const int BORDER_DOWN = 5;
enum GameState
{
GAMESTATE_MENU,
GAMESTATE_STARTED,
GAMESTATE_GAMEOVER
};
struct ScreenSize
{
int width;
int height;
};
class Bird
{
public:
static const int sizeX = 19;
static const int sizeY = 20;
static const int x = 100;
int prev_y;
int y;
int acceleration;
inline void initialize()
{
y = WINDOW_HEIGHT / 2;
acceleration = 0;
}
inline void move()
{
if (acceleration <= 30)
acceleration += 2;
prev_y = y;
y += acceleration / 10;
}
inline void jump()
{
acceleration = -50;
}
inline void draw()
{
kos_PutImage(birdImage, sizeX, sizeY, x, y);
}
};
class Tube
{
public:
static const int width = 50;
static const int gapHeight = 100;
static const int headHeight = 18;
int x;
int gapY;
inline void randomize()
{
x = WINDOW_WIDTH + 1;
gapY = rtlRand() % 200 + 50;
}
inline void move()
{
x -= 2;
if (x < -width - 2)
randomize();
}
void draw()
{
//cleanup
int pixels = (WINDOW_WIDTH - (BORDER_LEFT + BORDER_RIGHT - 1)) - (x + width + 2);
if (pixels >= -1)
{
pixels = (pixels == -1) ? 1 : 2;
kos_DrawBar(x + width, gapY - headHeight, pixels, headHeight, 0x00FFFF);
kos_DrawBar(x + width, gapY + gapHeight, pixels, headHeight, 0x00FFFF);
}
int offset = x >= 0 ? 0 : -x;
int trim = x + width >= WINDOW_WIDTH - (BORDER_LEFT + BORDER_RIGHT - 1) ? WINDOW_WIDTH - x - width - (BORDER_LEFT + BORDER_RIGHT - 1) : 0;
int trimHead = x + width >= WINDOW_WIDTH - (BORDER_LEFT + BORDER_RIGHT - 1) ? WINDOW_WIDTH - x - width - (BORDER_LEFT + BORDER_RIGHT - 1) : 0;
//top
for (int y = 0; y < gapY - headHeight; ++y)
kos_PutImage(tubeBodyImage + offset, width - offset + trim, 1, x + offset, y);
//head top
for (int y = gapY - headHeight; y < gapY; ++y)
kos_PutImage(tubeHeadImage + width * (y - (gapY - headHeight)) + offset, width - offset + trimHead, 1, x + offset, y);
//head down
for (int y = gapY + gapHeight; y < gapY + gapHeight + headHeight; ++y)
kos_PutImage(tubeHeadImage + width * (y - (gapY + gapHeight)) + offset, width - offset + trimHead, 1, x + offset, y);
//down
for (int y = gapY + gapHeight + headHeight; y < WINDOW_HEIGHT - (BORDER_TOP + BORDER_DOWN - 1); ++y)
kos_PutImage(tubeBodyImage + offset, width - offset + trim, 1, x + offset, y);
}
};
//Global variables
int loopDelay;
GameState gameState;
char scoreString[] = "Score: ";
bool scoreChanged;
int score;
Bird bird;
int tubeNumber;
Tube tubes[3];
int windowX;
int windowY;
//Function prototypes
void kos_Main();
void startGame();
ScreenSize getScreenSize();
void updateScoreString();
void WriteBorderedText(Word x, Word y, Byte fontType, Dword textColor, const char* textPtr, Dword textLen, Dword borderColor, int borderSize);
inline bool checkAddScore(Tube tube);
inline bool checkCollision(Tube tube);
void drawMenuWindow();
void drawGameWindow();
void redrawGameWindow();
void drawGameoverWindow();
//Functions
void startGame()
{
kos_SetMaskForEvents(0x7); /// 111 in binary
bird.initialize();
score = 0;
memset((Byte*)scoreString + 6, ' ', 3);
updateScoreString();
tubeNumber = 1;
tubes[0].randomize();
gameState = GAMESTATE_STARTED;
drawGameWindow();
}
ScreenSize getScreenSize()
{
Dword result;
__asm {
push 14 //System function 14
pop eax
int 0x40
mov result, eax
}
ScreenSize screenSize;
screenSize.height = (result & 0xFFFF) + 1; //last two bytes
screenSize.width = (result >> 16) + 1; //first two bytes
return screenSize;
}
void kos_Main()
{
rtlSrand( kos_GetSystemClock() );
//Centring window
ScreenSize screenSize = getScreenSize();
windowX = (screenSize.width - WINDOW_WIDTH) / 2;
windowY = (screenSize.height - WINDOW_HEIGHT) / 2;
gameState = GAMESTATE_MENU;
kos_SetMaskForEvents(0x27); // 100111 in binary
while( true )
{
switch (gameState)
{
case GAMESTATE_STARTED:
kos_Pause(loopDelay);
bird.move();
//Adding new tubes
if ((tubeNumber == 1 || tubeNumber == 2) && (tubes[tubeNumber - 1].x < (WINDOW_WIDTH - WINDOW_WIDTH / 3)))
tubes[tubeNumber++].randomize();
//Processing all tubes
scoreChanged = false;
for (int i = 0; i < tubeNumber; ++i)
{
//Adding score
if (checkAddScore(tubes[i]))
{
++score;
scoreChanged = true;
}
//Check collision with bird
if (checkCollision(tubes[i]))
{
gameState = GAMESTATE_GAMEOVER;
continue;
}
//Move tube
tubes[i].move();
}
if (scoreChanged)
updateScoreString();
//Cheking the bird is too high or low
if (bird.y + bird.sizeY > WINDOW_HEIGHT - (BORDER_TOP + BORDER_DOWN - 1) || bird.y < 0)
{
gameState = GAMESTATE_GAMEOVER;
continue;
}
redrawGameWindow();
switch (kos_CheckForEvent())
{
case 1:
drawGameWindow();
break;
case 2: // key pressed
Byte keyCode;
kos_GetKey(keyCode);
if (keyCode == 32) //if pressed key is spacebar
bird.jump();
break;
case 3: // button pressed; we have only one button, close
kos_ExitApp();
}
break;
case GAMESTATE_GAMEOVER:
drawGameoverWindow();
switch (kos_WaitForEvent())
{
case 1:
drawGameoverWindow();
break;
case 2:
startGame();
break;
case 3:
kos_ExitApp();
}
break;
case GAMESTATE_MENU:
switch (kos_WaitForEvent())
{
case 1:
drawMenuWindow();
break;
case 2:
Byte keyCode;
kos_GetKey(keyCode);
if (keyCode == 0x31 || keyCode == 0x61) //1 or NumPad1
{
loopDelay = 1;
startGame();
}
else if (keyCode == 0x32 || keyCode == 0x62) //2 or NumPad2
{
loopDelay = 2;
startGame();
}
break;
case 3:
kos_ExitApp();
case 6:
Dword result;
__asm {
push 37 //Function 37 - work with mouse
pop eax
mov ebx, 3 //Subfunction 3 - states and events of the mouse buttons
int 0x40
mov result, eax
}
result &= 0x100; //bit 8 is set = left button is pressed
if ( result )
{
Dword coordinates;
__asm {
push 37 //Function 37 - work with mouse
pop eax
mov ebx, 1 //Subfunction 1 - coordinates of the mouse relative to the window
int 0x40
mov coordinates, eax
}
int clickX = coordinates >> 16;
int clickY = coordinates & 0xFFFF;
if (clickX >= 100 && clickX < 390 && clickY >= 170 && clickY < 230)
{
loopDelay = 1;
startGame();
}
else if (clickX >= 100 && clickX < 390 && clickY >= 270 && clickY < 330)
{
loopDelay = 2;
startGame();
}
}
break;
}
break;
}
}
}
void drawGameWindow()
{
kos_DefineAndDrawWindow(windowX, windowY, WINDOW_WIDTH, WINDOW_HEIGHT, 0x33, 0x00FFFF, 0, 0, (Dword)HEADER_STRING);
bird.draw();
for (int i = 0; i < tubeNumber; ++i)
tubes[i].draw();
kos_WriteTextToWindow(10, 10, 0x81, 0x000000, scoreString, 0);
kos_WriteTextToWindow(10, 30, 0x81, 0x000000, CONTROL_STRING, 0);
}
void redrawGameWindow()
{
//cleaning the screen
if (scoreChanged)
kos_DrawBar(80, 10, 50, 15, 0x00FFFF);
if (bird.y > bird.prev_y)
kos_DrawBar(bird.x, bird.prev_y, bird.sizeX, bird.y - bird.prev_y, 0x00FFFF);
else
kos_DrawBar(bird.x, bird.y + bird.sizeY, bird.sizeX, bird.prev_y - bird.y, 0x00FFFF);
bird.draw();
for (int i = 0; i < tubeNumber; ++i)
tubes[i].draw();
kos_WriteTextToWindow(10, 10, 0x81, 0x000000, scoreString, 0);
kos_WriteTextToWindow(10, 30, 0x81, 0x000000, CONTROL_STRING, 0);
}
void drawGameoverWindow()
{
kos_DefineAndDrawWindow(windowX, windowY, WINDOW_WIDTH, WINDOW_HEIGHT, 0x33, 0x000000, 0, 0, (Dword)HEADER_STRING);
kos_WriteTextToWindow(125, 50, 0x82, 0xFFFFFF, GAMEOVER_STRING, 0);
kos_WriteTextToWindow(135, 100, 0x81, 0xFFFFFF, scoreString, 0);
kos_WriteTextToWindow(50, 150, 0x81, 0xFFFFFF, ANY_KEY_STRING, 0);
}
void WriteBorderedText(Word x, Word y, Byte fontType, Dword textColor, const char *textPtr, Dword textLen, Dword borderColor, int borderSize)
{
kos_WriteTextToWindow(x - borderSize, y - borderSize, fontType, borderColor, textPtr, textLen);
kos_WriteTextToWindow(x - borderSize, y + borderSize, fontType, borderColor, textPtr, textLen);
kos_WriteTextToWindow(x + borderSize, y - borderSize, fontType, borderColor, textPtr, textLen);
kos_WriteTextToWindow(x + borderSize, y + borderSize, fontType, borderColor, textPtr, textLen);
kos_WriteTextToWindow(x, y, fontType, textColor, textPtr, textLen);
}
void drawMenuWindow()
{
kos_DefineAndDrawWindow(windowX, windowY, WINDOW_WIDTH, WINDOW_HEIGHT, 0x33, 0x00FFFF, 0, 0, (Dword)HEADER_STRING);
WriteBorderedText(85, 40, 0x4, 0xFFFFFF, HEADER_STRING, 6, 0x000000, 2);
WriteBorderedText(185, 80, 0x84, 0xFFFFFF, HEADER_STRING + 7, 0, 0x000000, 2);
RGB* pos = &tubeHeadImage[0];
for (int x = 100 - 1; x >= 100 - Tube::headHeight; --x)
for (int y = 170; y < 170 + Tube::width; ++y)
{
kos_PutPixel(x, y, (pos->r << 16) + (pos->g << 8) + (pos->b)); //first tube
kos_PutPixel(x, y+100, (pos->r << 16) + (pos->g << 8) + (pos->b)); //second tube
++pos;
}
//First button
for(int x = 100; x < WINDOW_WIDTH - (BORDER_LEFT + BORDER_RIGHT - 1); ++x)
kos_PutImage(tubeBodyImage, 1, Tube::width, x, 170);
WriteBorderedText(140, 185, 0x82, 0x000000, FAST_STRING, 0, 0xFFFFFF, 1);
//Second button
for (int x = 100; x < WINDOW_WIDTH - (BORDER_LEFT + BORDER_RIGHT - 1); ++x)
kos_PutImage(tubeBodyImage, 1, Tube::width, x, 270);
WriteBorderedText(140, 285, 0x82, 0x000000, SLOW_STRING, 0, 0xFFFFFF, 1);
}
inline bool checkCollision(Tube tube)
{
return ((tube.x <= (bird.x + bird.sizeX) && tube.x + tube.width >= bird.x)
&& (bird.y <= tube.gapY || bird.y + bird.sizeY >= tube.gapY + tube.gapHeight));
}
inline bool checkAddScore(Tube tube)
{
//int diff = bird.x - (tube.x + tube.width);
//return diff == 0 || diff == 1;
return ((bird.x - (tube.x + tube.width)) >> 1) == 0;
}
void updateScoreString()
{
int temp = score;
int index = 9;
do {
scoreString[index--] = temp % 10 + '0';
temp /= 10;
} while (temp > 0);
}
-20
View File
@@ -1,20 +0,0 @@
Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "floppybird", "floppybird.vcxproj", "{0556BA3E-9447-4000-8613-91AD1CD750D7}"
ProjectSection(ProjectDependencies) = postProject
{0D291390-1953-4E1F-BBE2-57F12AFF3214} = {0D291390-1953-4E1F-BBE2-57F12AFF3214}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "smalllibc", "smalllibc\smalllibc.vcxproj", "{0D291390-1953-4E1F-BBE2-57F12AFF3214}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Release|Win32 = Release|Win32
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{0556BA3E-9447-4000-8613-91AD1CD750D7}.Release|Win32.ActiveCfg = Release|Win32
{0556BA3E-9447-4000-8613-91AD1CD750D7}.Release|Win32.Build.0 = Release|Win32
{0D291390-1953-4E1F-BBE2-57F12AFF3214}.Release|Win32.ActiveCfg = Release|Win32
{0D291390-1953-4E1F-BBE2-57F12AFF3214}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
EndGlobal
-51
View File
@@ -1,51 +0,0 @@
#pragma once
#include <kosSyst.h>
static RGB birdImage[] = {
0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0xC08040, 0xC08040, 0xC08040, 0x608080, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0x00FFFF, 0x40C0C0, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0xC08040, 0xE0C080, 0xC08040, 0xE0C080, 0x806040, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0xC0DCC0, 0xA06040, 0x80C0C0, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x80C0C0, 0xE0A040, 0xE0E080, 0xE0C080, 0xE0E080, 0x806040, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0xC08040, 0xE0C080, 0xA06040, 0x20C0C0, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0xC06040, 0xE0C080, 0xC0A080, 0xC0A080, 0xA0A080, 0x806040, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0xC08040, 0xE0C080, 0xE0E080, 0xA06040, 0x20C0C0, 0x00FFFF, 0x00FFFF, 0xA06040, 0xC08040, 0x800040, 0x800040, 0xE02080, 0xE060C0, 0x40C0C0, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0xA06040, 0xC08040, 0xE0E080, 0xC0DCC0, 0xA06040, 0x20C0C0, 0x20C0C0, 0xC06040, 0x808080, 0xE02080, 0xE020C0, 0xE02080, 0xE0A0C0, 0x804080, 0x40C0C0, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0xC08040, 0xE0A040, 0xE0C080, 0xE0E080, 0xFFFBF0, 0x806040, 0xC06040, 0xC0DCC0, 0x800040, 0xE040C0, 0xE040C0, 0x002040, 0xE0E080, 0xA0A080, 0x404040, 0x404040, 0x806080, 0x806080, 0xA08080,
0xA06040, 0xE0A040, 0xC08040, 0xE0C080, 0xFFFBF0, 0xC0DCC0, 0xA06040, 0xC0DCC0, 0xE020C0, 0xE0C080, 0xE0C080, 0xE0E080, 0xE0E000, 0xA0A0A4, 0xC0A080, 0x20A080, 0x40A0C0, 0x40A0C0, 0x60C0C0,
0x20C0C0, 0xA06040, 0xE0A040, 0xC08040, 0xE0C040, 0xFFFBF0, 0xC0C080, 0x80A040, 0xC00080, 0xFFFF00, 0xFFFF00, 0xE0E080, 0xC0A040, 0xA0A080, 0x60A080, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0x00FFFF, 0x80A080, 0xC08040, 0xE0A040, 0xE0A040, 0xE0C080, 0xFFFBF0, 0xC0C0C0, 0xE0C040, 0xE0E040, 0xC0E000, 0xC0C080, 0xA0A080, 0xC0C0C0, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0x00FFFF, 0x40C0C0, 0x80A080, 0xE0A040, 0xE0C080, 0xE0C040, 0xE0E080, 0x80E080, 0xC0E000, 0xE0E080, 0xE0E080, 0xE0E080, 0xC0A080, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0x00FFFF, 0x00FFFF, 0x40C0C0, 0xA06040, 0xA0C040, 0xA0A040, 0xA0C080, 0xC0E000, 0xC0E000, 0xE0E080, 0xE0E080, 0xE0E080, 0xE0E080, 0x40C080, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0x60E080, 0xC0DCC0, 0x00FFFF, 0x80C0C0, 0x606080, 0x606080, 0xA0E040, 0xC0E000, 0xE0E000, 0xE0E080, 0xE0E080, 0xE0E080, 0xC0C040, 0x60A040, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0xC0E080, 0xC0C000, 0xE0E000, 0xC0DCC0, 0x80A040, 0xA0E040, 0xA0C040, 0xC0E000, 0xE0E080, 0xE0E080, 0xE0E080, 0xC0E000, 0xC0C000, 0x60A040, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0xA0A0A4, 0xA0A080, 0xA0E040, 0xC0E000, 0x80A080, 0xA0C040, 0xC0E000, 0xE0E040, 0xE0E080, 0xE0E080, 0xC0E000, 0xA0E040, 0x808040, 0x20C0C0, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0xC0E080, 0xE0E000, 0xA0A080, 0x80A080, 0xA0C040, 0xE0E040, 0xE0E040, 0xE0E040, 0xC0E040, 0xC0E000, 0xA0E040, 0x808040, 0xA0C080, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0x80A080, 0xA0C000, 0xC0E000, 0xA0E040, 0xA0C040, 0xC0E000, 0xC0E000, 0xC0E000, 0xC0E000, 0xA0E040, 0x80A040, 0x80C0C0, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0xA0C000, 0x6080C0, 0xA0C040, 0xC0E000, 0xC0E000, 0xC0E000, 0xC0E000, 0xA0C040, 0x80A040, 0x808040, 0xA0C0C0, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0x80A080, 0xA0C080, 0xC0E000, 0xA0E040, 0xC0E040, 0x808040, 0x808040, 0x808040, 0xA0C0C0, 0x20C0C0, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF,
0xA0E080, 0x808040, 0xA0A040, 0x808040, 0x808040, 0x80C0C0, 0xA0C0C0, 0x20C0C0, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF, 0x00FFFF
};
static RGB tubeBodyImage[] = {
0x00FFFF, 0x00FFFF, 0x000000, 0x608040, 0x80E040, 0xE0E080, 0xA0E040, 0xA0E040, 0x80C040, 0x80C040, 0x80C040, 0x80C040, 0x80E040, 0x60A000, 0x60A000, 0x80E040, 0x80E040, 0x60A000, 0x40A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x40A000, 0x60A000, 0x408000, 0x408000, 0x204000, 0x60A000, 0x408000, 0x408000, 0x204000, 0x206000, 0x204000, 0x200040, 0x00FFFF, 0x00FFFF
};
static RGB tubeHeadImage[] = {
0x200040, 0x200040, 0x200040, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040,
0x402000, 0x408000, 0x408000, 0x608040, 0x80A040, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xC0C080, 0xA0C040, 0x60A040, 0x60A040, 0xA0C080, 0xA0C080, 0x60A040, 0x60A040, 0x80A040, 0x60A040, 0x60A040, 0x60A040, 0x60A040, 0x60A040, 0x80A040, 0x80A040, 0x80A040, 0x80A040, 0x608000, 0x406000, 0x204000, 0x204000, 0x402000,
0x402000, 0x60C000, 0x60C000, 0x80C040, 0xA0E040, 0xE0E080, 0xE0E080, 0xE0E080, 0xE0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xE0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0xC0E080, 0x80C040, 0x80C040, 0xC0E080, 0xC0E080, 0x80C040, 0x80C040, 0x80E040, 0x80C040, 0x80C040, 0x80E040, 0x80E040, 0x80E040, 0x80C040, 0x80C040, 0x80C040, 0x80E040, 0x60A000, 0x408000, 0x206000, 0x206000, 0x402000,
0x402040, 0x80E040, 0x80E040, 0xC0E080, 0xE0E080, 0x80C040, 0x80C040, 0x80C040, 0x80C040, 0x40A000, 0x60A000, 0x60A000, 0x80E040, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x204000, 0x406000, 0x406000, 0x60A000, 0x206000, 0x204000, 0x206000, 0x206000, 0x402000,
0x402040, 0x80E040, 0x80E040, 0xC0E080, 0xE0E080, 0x80C040, 0x80C040, 0x80C040, 0x80C040, 0x60A000, 0x60A000, 0x60A000, 0x80E040, 0x60A000, 0x40A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x206000, 0x406000, 0x406000, 0x60A000, 0x206000, 0x206000, 0x206000, 0x206000, 0x402000,
0x402040, 0x80E040, 0x80E040, 0xC0E080, 0xE0E080, 0x80C040, 0x80C040, 0x80C040, 0x80C040, 0x60A000, 0x60A000, 0x60A000, 0x80E040, 0x60A000, 0x40A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x206000, 0x406000, 0x406000, 0x60A000, 0x206000, 0x204000, 0x206000, 0x206000, 0x402000,
0x402040, 0x80E040, 0x80E040, 0xC0E080, 0xE0E080, 0x80C040, 0x80C040, 0x80C040, 0x80C040, 0x60A000, 0x60A000, 0x60A000, 0x80E040, 0x60A000, 0x40A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x206000, 0x406000, 0x406000, 0x60A000, 0x206000, 0x204000, 0x206000, 0x206000, 0x402000,
0x402040, 0x80E040, 0x80E040, 0xC0E080, 0xE0E080, 0x80C040, 0x80C040, 0x80C040, 0x80C040, 0x60A000, 0x60A000, 0x60A000, 0x80E040, 0x60A000, 0x40A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x206000, 0x406000, 0x406000, 0x60A000, 0x206000, 0x204000, 0x206000, 0x206000, 0x402000,
0x402040, 0x80E040, 0x80E040, 0xC0E080, 0xE0E080, 0x80C040, 0x80C040, 0x80C040, 0x80C040, 0x60A000, 0x60A000, 0x60A000, 0x80E040, 0x60A000, 0x40A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x206000, 0x406000, 0x406000, 0x60A000, 0x206000, 0x204000, 0x206000, 0x206000, 0x402000,
0x402040, 0x80E040, 0x80E040, 0xC0E080, 0xE0E080, 0x80C040, 0x80C040, 0x80C040, 0x80C040, 0x60A000, 0x60A000, 0x60A000, 0x80E040, 0x60A000, 0x40A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x206000, 0x406000, 0x406000, 0x60A000, 0x206000, 0x204000, 0x206000, 0x206000, 0x402000,
0x402040, 0x80E040, 0x80E040, 0xC0E080, 0xE0E080, 0x80C040, 0x80C040, 0x80C040, 0x80C040, 0x60A000, 0x60A000, 0x60A000, 0x80E040, 0x60A000, 0x40A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x206000, 0x406000, 0x406000, 0x60A000, 0x206000, 0x204000, 0x206000, 0x206000, 0x402000,
0x402040, 0x80E040, 0x80E040, 0xC0E080, 0xE0E080, 0x80C040, 0x80C040, 0x80C040, 0x80C040, 0x60A000, 0x60A000, 0x60A000, 0x80E040, 0x60A000, 0x40A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x206000, 0x406000, 0x406000, 0x60A000, 0x206000, 0x204000, 0x206000, 0x206000, 0x402000,
0x402040, 0x80E040, 0x80E040, 0xC0E080, 0xE0E080, 0x80C040, 0x80C040, 0x80C040, 0x80C040, 0x60A000, 0x60A000, 0x60A000, 0x80E040, 0x60A000, 0x40A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x206000, 0x406000, 0x406000, 0x60A000, 0x206000, 0x204000, 0x206000, 0x206000, 0x402000,
0x402040, 0x80E040, 0x80E040, 0xC0E080, 0xE0E080, 0x80C040, 0x80C040, 0x80C040, 0x80C040, 0x40A000, 0x60A000, 0x60A000, 0x80E040, 0x60A000, 0x40A000, 0x60A000, 0x60A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x40A000, 0x60A000, 0x206000, 0x406000, 0x406000, 0x60A000, 0x206000, 0x204000, 0x206000, 0x206000, 0x402000,
0x402040, 0x80E040, 0x80E040, 0xC0E080, 0xE0E080, 0x80E040, 0x80E040, 0x80E040, 0x80E040, 0x60A000, 0x60C000, 0x60C000, 0xA0E040, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x60A000, 0x206000, 0x406000, 0x406000, 0x60A000, 0x206000, 0x204000, 0x206000, 0x206000, 0x402000,
0x402000, 0x408000, 0x408000, 0x608000, 0x608040, 0x408000, 0x408000, 0x408000, 0x408000, 0x406000, 0x408000, 0x408000, 0x408000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x406000, 0x206000, 0x206000, 0x206000, 0x406000, 0x206000, 0x206000, 0x206000, 0x206000, 0x402000,
0x402000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x204000, 0x206000, 0x206000, 0x402000,
0x200040, 0x200040, 0x200040, 0x200040, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x200040, 0x200040, 0x000000, 0x000000, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040, 0x200040
};
@@ -1,68 +0,0 @@
filename equ '%EXENAME%'
virtual at 0
file filename:3Ch,4
load pehea dword from 0
file filename:pehea,0F8h+28h*3
load NumberOfSections word from 4+6
load SizeOfOptionalHeader word from 4+14h
if NumberOfSections<>3
error Expected three sections, .text, .bss and .reloc
end if
if SizeOfOptionalHeader<>0E0h
error Nonstandard PE header
end if
load RelocsRVA dword from 4+0A0h
load RelocsSize dword from 4+0A4h
load ImageBase dword from 4+34h
load TextRVA dword from 4+0F8h+0Ch
load TextSize dword from 4+0F8h+8
load TextOffs dword from 4+0F8h+14h
load BSSSize dword from 4+0F8h+28h+10h
load RelocRVA dword from 4+0F8h+28h*2+0Ch
load RelocOffs dword from 4+0F8h+28h*2+14h
if BSSSize
error Second section expected to be .bss
end if
if RelocRVA<>RelocsRVA
error Third section expected to be .reloc
end if
;file 'test.exe':pehea+0F8h,28h
;load physofs dword from 4+14h
;load mem dword from 4+8
;file 'test.exe':physofs+16,4
;load sz dword from $-4
end virtual
file filename:TextOffs,TextSize
while RelocsSize>8
virtual at 0
file filename:RelocOffs,8
load CurRelocPage dword from 0
load CurRelocChunkSize dword from 4
end virtual
RelocsSize=RelocsSize-CurRelocChunkSize
CurRelocChunkSize = CurRelocChunkSize-8
RelocOffs=RelocOffs+8
while CurRelocChunkSize
virtual at 0
file filename:RelocOffs,2
RelocOffs=RelocOffs+2
CurRelocChunkSize=CurRelocChunkSize-2
load s word from 0
end virtual
CurRelocType = s shr 12
RelocItem = CurRelocPage + (s and 0xFFF)
if CurRelocType=0
else if CurRelocType=3
load z dword from RelocItem-TextRVA
store dword z-(TextRVA+ImageBase) at RelocItem-TextRVA
else
error Unexpected relocation type
end if
end while
end while
store dword TextSize at 10h
store dword RelocRVA-TextRVA at 14h
@@ -1,501 +0,0 @@
#include "func.h"
int convert_error = 0;
int SysColor = 0;
char debuf[50] = "";
// яюўхьє-Єю эх с√ыю т ёЄрэфрЁЄэющ сшсышюЄхъх
void kos_DrawLine( Word x1, Word y1, Word x2, Word y2, Dword colour, Dword invert )
{
Dword arg1, arg2, arg3;
//
arg1 = ( x1 << 16 ) | x2;
arg2 = ( y1 << 16 ) | y2;
arg3 = (invert)?0x01000000:colour;
//
__asm{
mov eax, 38
mov ebx, arg1
mov ecx, arg2
mov edx, arg3
int 0x40
}
}
// яюїш∙хэю шч сшсышюЄхъш ъ C--
void DrawRegion(Dword x,Dword y,Dword width,Dword height,Dword color1)
{
kos_DrawBar(x,y,width,1,color1); //яюыюёр уюЁ ётхЁїє
kos_DrawBar(x,y+height,width,1,color1); //яюыюёр уюЁ ёэшчє
kos_DrawBar(x,y,1,height,color1); //яюыюёр тхЁЄ ёыхтр
kos_DrawBar(x+width,y,1,height+1,color1); //яюыюёр тхЁЄ ёяЁртр
}
// фр, ¤Єю ср э
int atoi(const char* string)
{
int res=0;
int sign=0;
const char* ptr;
for (ptr=string; *ptr && *ptr<=' ';ptr++);
if (*ptr=='-') {sign=1;++ptr;}
while (*ptr >= '0' && *ptr <= '9')
{
res = res*10 + *ptr++ - '0';
}
if (sign) res = -res;
return res;
}
/*int abs(int n)
{
return (n<0)?-n:n;
}*/
double fabs(double x)
{
__asm fld x
__asm fabs
}
#define M_PI 3.14159265358979323846
double cos(double x)
{
__asm fld x
__asm fcos
}
double sin(double x)
{
__asm fld x
__asm fsin
}
bool isalpha(char c)
{
return (c==' ' || c=='\n' || c=='\t' || c=='\r');
}
// ¤Єр ЇєэъЎш  - тхыюёшяхф. эю яЁю∙х с√ыю эряшёрЄ№ ўхь эрщЄш.
double convert(char *s, int *len)
{
int i;
double sign,res, tail, div;
convert_error = 0;
res = 0.0;
i=0;
while (s[i] && isalpha(s[i])) i++;
if (len) *len=i;
if (s[i] == '\0')
{
convert_error = ERROR_END;
return 0.0;
}
sign=1.0;
if (s[i] == '-')
{
sign=-1.0;
i++;
}
while (s[i] && s[i] >= '0' && s[i] <= '9')
{
res *= 10.0;
res += id(s[i] - '0');
i++;
}
if (len) *len=i;
if (!s[i] || isalpha(s[i]))
return sign*res;
if (s[i] != '.' && s[i] != ',')
{
convert_error = ERROR;
return 0;
}
i++;
if (len) *len=i;
if (!s[i])
return sign*res;
div = 1.0;
tail = 0.0;
while (s[i] && s[i] >= '0' && s[i] <= '9')
{
tail *= 10.0;
tail += id(s[i] - '0');
div *= 10.0;
i++;
}
res += tail/div;
if (len) *len=i;
return sign*res;
}
/*
#define PREC 2
double double_tab[]={1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15};
// ¤Єю sprintf, єьх■∙шщ ЇюЁьрЄшЁютрЄ№ _Єюы№ъю_ тх∙хёЄтхээ√х ўшёыр (double) %f
void format( char *Str, int len, char* Format, ... )
{
int i, fmtlinesize, j, k, flag;
char c;
va_list arglist;
//
va_start(arglist, Format);
//
fmtlinesize = strlen( Format );
//
if( fmtlinesize == 0 ) return;
for (i = 0; i < len; i++)
Str[i] = 0;
//
for( i = 0, j = 0; i < fmtlinesize; i++ )
{
//
c = Format[i];
//
if( c != '%' )
{
Str[j++] = c;
continue;
}
//
i++;
//
if( i >= fmtlinesize ) break;
//
flag = 0;
//
c = Format[i];
//
switch( c )
{
//
case '%':
Str[j++] = c;
break;
// auaia aauanoaaiiiai ?enea
case 'f':
// ii?aaaeeou ?enei oeo? ai oi?ee
double val, w;
int p;
val = va_arg(arglist, double);
if (val < 0.0)
{
Str[j++] = '-';
val = -val;
}
for (k = 0; k < 15; k++)
if (val < double_tab[k])
break;
if (val < 1.0)
{
Str[j++] = '0';
}
for (p = 1; p < k + 1; p++)
{
Str[j++] = '0' + di(val / double_tab[k - p] - 0.499) % 10;
}
Str[j++] = '.';
w = 0.1;
for (p = 0; p < 2; p++)
{
val-=floor(val);
Str[j++] = '0' + di(val / w - 0.499) % 10;
w /= 10.0;
}
//
default:
break;
}
}
//
Str[j] = 0;
}
void *memcpy(void *dst, const void *src, unsigned size)
{
while (size--)
*((char*)dst+size) = *((char*)src+size);
return dst;
}
*/
int strcmp(const char *s1, const char *s2)
{
int i;
if (s1 == NULL)
if (s2 == NULL)
return 0;
else
return 1;
else
if (s2 == NULL)
return 1;
for (i = 0;;i++)
{
if (s1[i] == '\0')
if (s2[i] == '\0')
return 0;
else
return 1;
else
if (s2[i] == '\0')
return 1;
else
{
if (s1[i] != s2[i])
return 1;
}
}
return 0;
}
kol_struct_import* kol_cofflib_load(char *name)
{
//asm ("int $0x40"::"a"(68), "b"(19), "c"(name));
__asm
{
mov eax, 68
mov ebx, 19
mov ecx, name
int 0x40
}
}
void* kol_cofflib_procload (kol_struct_import *imp, char *name)
{
int i;
for (i=0;;i++)
if ( NULL == ((imp+i) -> name))
break;
else
if ( 0 == strcmp(name, (imp+i)->name) )
return (imp+i)->data;
return NULL;
}
unsigned kol_cofflib_procnum (kol_struct_import *imp)
{
unsigned i, n;
for (i=n=0;;i++)
if ( NULL == ((imp+i) -> name))
break;
else
n++;
return n;
}
void kol_cofflib_procname (kol_struct_import *imp, char *name, unsigned n)
{
unsigned i;
*name = 0;
for (i=0;;i++)
if ( NULL == ((imp+i) -> name))
break;
else
if ( i == n )
{
strcpy(name, ((imp+i)->name));
break;
}
}
/*
end of system part
*/
// яюёъюы№ъє   яюЁЄшЁютры ё фЁхтэхую фюёр...
void line( int x1, int y1, int x2, int y2)
{
kos_DrawLine(x1,y1,x2,y2,SysColor,0);
}
void outtextxy( int x, int y, char *s, int len)
{
kos_WriteTextToWindow(x,y,0,SysColor,s,len);
}
double textwidth( char *s, int len)
{
int i;
for (i = 0; i < len; i++)
if (s[i] == 0)
break;
return id(i * 6);
}
double textheight( char *s, int len)
{
return 8.0;
}
void setcolor( DWORD color)
{
SysColor = color;
}
void rectangle( int x1, int y1, int x2, int y2)
{
kos_DrawBar(x1,y1,x2-x1,y2-y1,SysColor);
}
Dword kos_GetSkinHeight()
{
__asm{
mov eax, 48
mov ebx, 4
int 0x40
}
}
Dword kos_GetSpecialKeyState()
{
__asm{
mov eax, 66
mov ebx, 3
int 0x40
}
}
Dword kos_GetSlotByPID(Dword PID)
{
__asm
{
push ebx
push ecx
mov eax, 18
mov ebx, 21
mov ecx, PID
int 0x40
pop ecx
pop ebx
}
}
Dword kos_GetActiveSlot()
{
__asm
{
push ebx
mov eax, 18
mov ebx, 7
int 0x40
pop ebx
}
}
void kos_GetScrollInfo(int &vert, int &hor)
{
short v, h;
__asm
{
mov eax, 37
mov ebx, 7
int 0x40
mov ebx, eax
and eax, 0xffff
mov v, ax
shr ebx, 16
mov h, bx
}
vert = v;
hor = h;
}
// яюыєўхэшх шэЇюЁьрЎшш ю ёюёЄю эшш "ь√°ш" ЇєэъЎш  37/1
void kos_GetMouseStateWnd( Dword & buttons, int & cursorX, int & cursorY )
{
Dword mB;
Word curX;
Word curY;
sProcessInfo sPI;
//
__asm{
mov eax, 37
mov ebx, 1
int 0x40
mov curY, ax
shr eax, 16
mov curX, ax
mov eax, 37
mov ebx, 2
int 0x40
mov mB, eax
}
//
kos_ProcessInfo( &sPI );
//
buttons = mB;
cursorX = curX - sPI.processInfo.x_start;
cursorY = curY - sPI.processInfo.y_start;
}
double atof(char *s)
{
return convert(s, NULL);
}
int di(double x)
{
int a;
__asm fld x
__asm fistp a
return a;
}
double id(int x)
{
double a;
__asm fild x
__asm fstp a
return a;
}
-129
View File
@@ -1,129 +0,0 @@
#pragma once
#include "kosSyst.h"
#include "kosFile.h"
#include "MCSMEMM.H"
#include <stdarg.h>
#define min(a,b) (((a)<(b))?(a):(b))
#define max(a,b) (((a)>(b))?(a):(b))
#define ERROR -1
#define ERROR_END -2
extern int convert_error;
typedef int HDC;
typedef int DWORD;
extern int SysColor;
extern char debuf[50];
typedef double (*function_t)(double);
typedef struct
{
double x, y;
} TCoord;
struct kosBDVK
{
Dword attrib;
Dword name_type;
Dword create_time;
Dword create_date;
Dword access_time;
Dword access_date;
Dword modify_time;
Dword modify_date;
Dword size_low;
Dword size_high;
};
Dword kos_GetSlotByPID(Dword PID);
Dword kos_GetActiveSlot();
Dword kos_GetSkinHeight();
Dword kos_GetSpecialKeyState();
void kos_GetMouseStateWnd( Dword & buttons, int & cursorX, int & cursorY );
void kos_DrawLine( Word x1, Word y1, Word x2, Word y2, Dword colour, Dword invert);
void DrawRegion(Dword x,Dword y,Dword width,Dword height,Dword color1);
int atoi(const char* string);
void kos_GetScrollInfo(int &vert, int &hor);
Dword kos_GetSlotByPID(Dword PID);
Dword kos_GetActiveSlot();
Dword kos_GetSkinHeight();
Dword kos_GetSpecialKeyState();
double fabs(double x);
double cos(double x);
double sin(double x);
bool isalpha(char c);
double convert(char *s, int *len=NULL);
void format( char *Str, int len, char* Format, ... );
void line( int x1, int y1, int x2, int y2);
void outtextxy( int x, int y, char *s, int len);
void settextstyle( int a1, int a2, int a3);
double textwidth( char *s, int len);
double textheight( char *s, int len);
void setcolor( DWORD color);
void unsetcolor(HDC hdc);
void rectangle( int x1, int y1, int x2, int y2);
typedef struct
{
unsigned p00 ;
unsigned p04 ;
unsigned p08 ;
unsigned p12 ;
unsigned p16 ;
char p20 ;
char *p21 ;
} kol_struct70 ;
typedef struct
{
unsigned p00 ;
char p04 ;
char p05[3] ;
unsigned p08 ;
unsigned p12 ;
unsigned p16 ;
unsigned p20 ;
unsigned p24 ;
unsigned p28 ;
unsigned p32[2] ;
unsigned p40 ;
} kol_struct_BDVK ;
typedef struct
{
char *name ;
void *data ;
} kol_struct_import ;
kol_struct_import* kol_cofflib_load(char *name);
void* kol_cofflib_procload (kol_struct_import *imp, char *name);
unsigned kol_cofflib_procnum (kol_struct_import *imp);
void kol_cofflib_procname (kol_struct_import *imp, char *name, unsigned n);
int strcmp(const char* string1, const char* string2);
char *ftoa(double d);
double atof(char *s);
int di(double x);
double id(int x);
@@ -1,31 +0,0 @@
format MS COFF
StackSize = 16384
; must be alphabetically first in the image
section '.1seg' data readable writable
extrn _crtStartUp ; real entry point
extrn _kosCmdLine
extrn _kosExePath
extrn _exeStack
public fakeEntry
kos_header:
db 'MENUET01' ; header
dd 1 ; headerver
dd _crtStartUp ; entry
dd 0 ; i_end, filled by doexe2.asm
dd 0 ; memsize, filled by doexe2.asm
dd _exeStack + StackSize ; stack
dd _kosCmdLine ; params
dd _kosExePath ; icon
fakeEntry: ; only for linker, to force including this obj file
; real entry is crtStartUp
; initializers
section '.CRT$XCA' data readable writable
public ___xc_a
___xc_a:
section '.CRT$XCZ' data readable writable
public ___xc_z
___xc_z:
@@ -1,132 +0,0 @@
#include "kosSyst.h"
#include "kosFile.h"
//#include "string.h"
CKosFile::CKosFile(char *fileName)
{
//
this->fileInfo.bufferPtr = new Byte[FILE_BUFFER_SIZE];
//
this->filePointer = 0;
this->bufferPointer = 0;
this->validBuffer = false;
//
strcpy( this->fileInfo.fileURL, fileName );
}
CKosFile::~CKosFile(void)
{
//
delete this->fileInfo.bufferPtr;
}
void CKosFile::ValidateBuffer()
{
//
if ( this->validBuffer )
{
//
if ( this->filePointer < this->bufferPointer
|| this->filePointer >= (this->bufferPointer + FILE_BUFFER_SIZE) )
{
//
this->validBuffer = false;
}
}
}
void CKosFile::UpdateBuffer(void)
{
//
if ( ! this->validBuffer )
{
//
this->fileInfo.OffsetLow = this->filePointer / OS_BLOCK_SIZE;
this->fileInfo.OffsetHigh = 0;
//
this->bufferPointer = this->fileInfo.OffsetLow * OS_BLOCK_SIZE;
//
this->fileInfo.dataCount = FILE_BUFFER_BLOCKS;
//
this->fileInfo.rwMode = 0;
//
Dword rr = kos_FileSystemAccess( &(this->fileInfo) );
this->validBuffer = ( rr == 0 );
}
}
int CKosFile::Seek(int seekFrom, int seekStep)
{
//
switch ( seekFrom )
{
//
case SEEK_SET:
//
this->filePointer = seekStep;
break;
//
case SEEK_CUR:
//
this->filePointer += seekStep;
break;
}
//
this->ValidateBuffer();
//
return this->filePointer;
}
int CKosFile::Read(Byte *targetPtr, int readCount)
{
int bufferLeast, result;
//
result = 0;
//
do
{
//
this->UpdateBuffer();
//
if ( ! this->validBuffer ) return result;
//
bufferLeast = FILE_BUFFER_SIZE - (this->filePointer - this->bufferPointer);
//
if ( bufferLeast > readCount ) bufferLeast = readCount;
//
if ( bufferLeast )
{
//
memcpy(
targetPtr,
this->fileInfo.bufferPtr + (this->filePointer - this->bufferPointer),
bufferLeast
);
//
targetPtr += bufferLeast;
readCount -= bufferLeast;
this->filePointer += bufferLeast;
//
result += bufferLeast;
}
//
this->ValidateBuffer();
}
while ( readCount > 0 );
//
return result;
}
int CKosFile::Write(Byte *sourcePtr, int writeCount)
{
return 0;
}
@@ -1,26 +0,0 @@
#pragma once
#define SEEK_SET 0
#define SEEK_CUR 1
#define FILE_BUFFER_SIZE 512
#define OS_BLOCK_SIZE 1
#define FILE_BUFFER_BLOCKS (FILE_BUFFER_SIZE / OS_BLOCK_SIZE)
class CKosFile
{
public:
CKosFile(char *fileName);
~CKosFile(void);
int Read(Byte *targetPtr, int readCount);
int Write(Byte *sourcePtr, int writeCount);
int Seek(int seekFrom, int seekStep);
protected:
int filePointer;
int bufferPointer;
bool validBuffer;
kosFileInfo fileInfo;
void ValidateBuffer(void);
void UpdateBuffer(void);
};
@@ -1,695 +0,0 @@
#include "kosSyst.h"
#include "func.h"
#include <stdarg.h>
char kosCmdLine[257];
char kosExePath[1024];
extern "C" char exeStack[];
char exeStack[16384];
#define atexitBufferSize 32
#ifndef SMALLLIBC_NO_ATEXIT
//
void (__cdecl *atExitList[atexitBufferSize])();
int atExitFnNum = 0;
//
int __cdecl atexit( void (__cdecl *func )( void ))
{
//
if ( atExitFnNum < atexitBufferSize )
{
//
atExitList[atExitFnNum++] = func;
return 0;
}
else
{
return 1;
}
}
#endif
//
Dword RandomSeed = 0;
//
void rtlSrand( Dword seed )
{
RandomSeed = seed;
}
//
Dword rtlRand( void )
{
//ьрёър 0x80000776
Dword dwi, i;
for ( i = 0; i < 32; i++ )
{
dwi = RandomSeed & 0x80000776;
__asm{
mov eax, dwi
mov edx, eax
bswap eax
xor eax, edx
xor al, ah
setpo al
movzx eax, al
mov dwi, eax
}
RandomSeed = ( RandomSeed << 1 ) | ( dwi & 1 );
}
return RandomSeed;
}
void* __cdecl memcpy( void *dst, const void *src, size_t bytesCount )
{
__asm{
mov edi, dst
mov eax, dst
mov esi, src
mov ecx, bytesCount
rep movsb
}
}
//
void memset( Byte *dst, Byte filler, Dword count )
{
//
__asm{
mov edi, dst
mov al, filler
mov ecx, count
rep stosb
}
}
//
Dword rtlInterlockedExchange( Dword *target, Dword value )
{
// Dword result;
//
__asm{
mov eax, value
mov ebx, target
xchg eax, [ebx]
// mov result, eax
}
//
// return result;
}
//////////////////////////////////////////////////////////////////////
//
// ъюяшЁютрэшх ёЄЁюъш
//
char * __cdecl strcpy( char *target, const char *source )
{
char *result = target;
while( target[0] = source[0] )
{
target++;
source++;
}
return result;
}
//////////////////////////////////////////////////////////////////////
//
// ЁхтхЁёштэ√щ яюшёъ ёшьтюыр
//
char * __cdecl strrchr( const char * string, int c )
{
char *cPtr;
//
for ( cPtr = (char *)string + strlen( string ); cPtr >= string; cPtr-- )
{
//
if ( *cPtr == c ) return cPtr;
}
//
return NULL;
}
//////////////////////////////////////////////////////////////////////
//
// юяЁхфхыхэшх фышэ√ ёЄЁюъш
//
int __cdecl strlen( const char *line )
{
int i;
for( i=0; line[i] != 0; i++ );
return i;
}
//////////////////////////////////////////////////////////////////////
//
// яхЁхтюф °хёЄэрфЎрЄшЁшўэюую ўшёыр т ёшьтюы
//
unsigned int num2hex( unsigned int num )
{
if( num < 10 )
return num + '0';
return num - 10 + 'A';
}
inline void __declspec(noreturn) kos_sysfuncm1(void)
{
__asm or eax, -1
__asm int 0x40
}
// ЇєэъЎш  -1 чртхЁ°хэш  яЁюЎхёёр
void kos_ExitApp()
{
#ifndef SMALLLIBC_NO_ATEXIT
int i;
//
for ( i = atExitFnNum - 1; i >= 0; i-- )
{
//
atExitList[i]();
}
#endif
//
kos_sysfuncm1();
}
static void __declspec(noinline) __fastcall kos_sysfunc0(Dword _ecx, Dword _edx, Dword _ebx, Dword _esi, Dword _edi)
{
__asm xor eax, eax
__asm mov ebx, _ebx
__asm mov esi, _esi
__asm mov edi, _edi
__asm int 0x40
}
// ЇєэъЎш  0
void kos_DefineAndDrawWindow(
Word x, Word y,
Word sizeX, Word sizeY,
Byte mainAreaType,
Dword mainAreaColour,
Byte headerType,
Dword headerColour,
Dword borderColour
)
{
Dword arg1, arg2, arg3, arg4;
//
arg1 = ( x << 16 ) + sizeX;
arg2 = ( y << 16 ) + sizeY;
arg3 = ( mainAreaType << 24 ) | mainAreaColour;
arg4 = ( headerType << 24 ) | headerColour;
//
kos_sysfunc0(arg2, arg3, arg1, arg4, borderColour);
}
// ЇєэъЎш  1 яюёЄртшЄ№ Єюўъє
void kos_PutPixel( Dword x, Dword y, Dword colour )
{
//
__asm{
push 1
pop eax
mov ebx, x
mov ecx, y
mov edx, colour
int 0x40
}
}
inline Dword kos_sysfunc2(void)
{
__asm push 2
__asm pop eax
__asm int 0x40
}
// ЇєэъЎш  2 яюыєўшЄ№ ъюф эрцрЄющ ъыртш°ш
bool kos_GetKey( Byte &keyCode )
{
Dword result = kos_sysfunc2();
//
keyCode = result >> 8;
//
return ( result & 0xFF ) == 0;
}
// ЇєэъЎш  3 яюыєўшЄ№ тЁхь 
Dword kos_GetSystemClock()
{
// Dword result;
//
__asm{
push 3
pop eax
int 0x40
// mov result, eax
}
//
// return result;
}
static void __declspec(noinline) __fastcall kos_sysfunc4(Dword _ecx, const char* _edx, Dword _ebx, Dword _esi)
{
__asm push 4
__asm pop eax
__asm mov ebx, [_ebx]
__asm mov esi, [_esi]
__asm int 0x40
}
// ЇєэъЎш  4
void kos_WriteTextToWindow(
Word x,
Word y,
Byte fontType,
Dword textColour,
const char *textPtr,
Dword textLen
)
{
Dword arg1, arg2;
//
arg1 = ( x << 16 ) | y;
arg2 = ( fontType << 24 ) | textColour;
//
kos_sysfunc4(arg2, textPtr, arg1, textLen);
}
// ЇєэъЎш  5 ярєчр, т ёюЄ√ї фюы ї ёхъєэф√
void kos_Pause( Dword value )
{
//
__asm{
push 5
pop eax
mov ebx, value
int 0x40
}
}
// ЇєэъЎш  7 эрЁшёютрЄ№ шчюсЁрцхэшх
void kos_PutImage( RGB * imagePtr, Word sizeX, Word sizeY, Word x, Word y )
{
Dword arg1, arg2;
//
arg1 = ( sizeX << 16 ) | sizeY;
arg2 = ( x << 16 ) | y;
//
__asm{
push 7
pop eax
mov ebx, imagePtr
mov ecx, arg1
mov edx, arg2
int 0x40
}
}
// ЇєэъЎш  8 юяЁхфхышЄ№ ъэюяъє
void kos_DefineButton( Word x, Word y, Word sizeX, Word sizeY, Dword buttonID, Dword colour )
{
Dword arg1, arg2;
//
arg1 = ( x << 16 ) | sizeX;
arg2 = ( y << 16 ) | sizeY;
//
__asm{
push 8
pop eax
mov ebx, arg1
mov ecx, arg2
mov edx, buttonID
mov esi, colour
int 0x40
}
}
// ЇєэъЎш  9 - шэЇюЁьрЎш  ю яЁюЎхёёх
Dword kos_ProcessInfo( sProcessInfo *targetPtr, Dword processID )
{
// Dword result;
//
__asm{
push 9
pop eax
mov ebx, targetPtr
mov ecx, processID
int 0x40
// mov result, eax
}
//
// return result;
}
// ЇєэъЎш  10
Dword kos_WaitForEvent()
{
// Dword result;
__asm{
push 10
pop eax
int 0x40
// mov result, eax
}
// return result;
}
// ЇєэъЎш  11
Dword kos_CheckForEvent()
{
Dword result; //
__asm{
push 11
pop eax
int 0x40
mov result, eax //
}
return result; //
}
// ЇєэъЎш  12
void kos_WindowRedrawStatus( Dword status )
{
__asm{
push 12
pop eax
mov ebx, status
int 0x40
}
}
// ЇєэъЎш  13 эрЁшёютрЄ№ яюыюёє
void kos_DrawBar( Word x, Word y, Word sizeX, Word sizeY, Dword colour )
{
Dword arg1, arg2;
//
arg1 = ( x << 16 ) | sizeX;
arg2 = ( y << 16 ) | sizeY;
//
__asm{
push 13
pop eax
mov ebx, arg1
mov ecx, arg2
mov edx, colour
int 0x40
}
}
// ЇєэъЎш  17
bool kos_GetButtonID( Dword &buttonID )
{
Dword result;
//
__asm{
push 17
pop eax
int 0x40
mov result, eax
}
//
buttonID = result >> 8;
//
return (result & 0xFF) == 0;
}
// ЇєэъЎш  23
Dword kos_WaitForEventTimeout( Dword timeOut )
{
// Dword result;
__asm{
push 23
pop eax
mov ebx, timeOut
int 0x40
// mov result, eax
}
// return result;
}
// яюыєўхэшх шэЇюЁьрЎшш ю ёюёЄю эшш "ь√°ш" ЇєэъЎш  37
void kos_GetMouseState( Dword & buttons, int & cursorX, int & cursorY )
{
Dword mB;
Word curX;
Word curY;
sProcessInfo sPI;
//
__asm{
push 37
pop eax
xor ebx, ebx
int 0x40
mov curY, ax
shr eax, 16
mov curX, ax
push 37
pop eax
push 2
pop ebx
int 0x40
mov mB, eax
}
//
kos_ProcessInfo( &sPI );
//
buttons = mB;
cursorX = curX - sPI.processInfo.x_start;
cursorY = curY - sPI.processInfo.y_start;
}
// ЇєэъЎш  40 єёЄрэютшЄ№ ьрёъє ёюс√Єшщ
void kos_SetMaskForEvents( Dword mask )
{
//
__asm{
push 40
pop eax
mov ebx, mask
int 0x40
}
}
// ЇєэъЎш  47 т√тхёЄш т юъэю яЁшыюцхэш  ўшёыю
void kos_DisplayNumberToWindow(
Dword value,
Dword digitsNum,
Word x,
Word y,
Dword colour,
eNumberBase nBase,
bool valueIsPointer
)
{
Dword arg1, arg2;
//
arg1 = ( valueIsPointer ? 1 : 0 ) |
( ((Byte)nBase) << 8 ) |
( ( digitsNum & 0x1F ) << 16 );
arg2 = ( x << 16 ) | y;
//
__asm{
push 47
pop eax
mov ebx, arg1
mov ecx, value
mov edx, arg2
mov esi, colour
int 0x40
}
}
// ЇєэъЎш  70 фюёЄєя ъ Їрщыютющ ёшёЄхьх
Dword kos_FileSystemAccess( kosFileInfo *fileInfo )
{
// Dword result;
//
__asm{
push 70
pop eax
mov ebx, fileInfo
int 0x40
// mov result, eax
}
//
// return result;
}
// ЇєэъЎш  63 т√тюф ёшьтюы  т юъэю юЄырфъш
void kos_DebugOutChar( char ccc )
{
//
__asm{
push 63
pop eax
push 1
pop ebx
mov cl, ccc
int 0x40
}
}
// ЇєэъЎш  66 Ёхцшь яюыєўхэш  фрээ√ї юЄ ъыртшрЄєЁ√
void kos_SetKeyboardDataMode( Dword mode )
{
//
__asm{
push 66
pop eax
push 1
pop ebx
mov ecx, mode
int 0x40
}
}
// т√тюф ёЄЁюъш т юъэю юЄырфъш
void rtlDebugOutString( char *str )
{
//
for ( ; str[0] != 0; str++ )
{
kos_DebugOutChar( str[0] );
}
//
kos_DebugOutChar( 13 );
kos_DebugOutChar( 10 );
}
// ЇєэъЎш  64 шчьхэхэшх ъюышўхёЄтр ярь Єш, т√фхыхээющ фы  яЁюуЁрьь√
bool kos_ApplicationMemoryResize( Dword targetSize )
{
Dword result;
//
__asm{
push 64
pop eax
push 1
pop ebx
mov ecx, targetSize
int 0x40
mov result, eax
}
//
return result == 0;
}
// ЇєэъЎш  67 шчьхэшЄ№ ярЁрьхЄЁ√ юъэр, ярЁрьхЄЁ == -1 эх ьхэ хЄё 
void kos_ChangeWindow( Dword x, Dword y, Dword sizeX, Dword sizeY )
{
//
__asm{
push 67
pop eax
mov ebx, x
mov ecx, y
mov edx, sizeX
mov esi, sizeY
int 0x40
}
}
void kos_InitHeap()
{
__asm{
push 68
pop eax
push 11
pop ebx
int 0x40
}
}
// т√чют ёЄрЄшўхёъшї шэшЎшрышчрЄюЁют
typedef void (__cdecl *_PVFV)(void);
extern "C" _PVFV __xc_a[];
extern "C" _PVFV __xc_z[];
#pragma comment(linker, "/merge:.CRT=.rdata")
//
void __cdecl crtStartUp()
{
#ifndef SMALLLIBC_NO_INIT
// т√ч√трхь шэшЎшрышчрЄюЁ√ яю ёяшёъє
for ( _PVFV *pbegin = __xc_a; pbegin < __xc_z; pbegin++ )
{
//
(**pbegin)();
}
#endif
// шэшЎшрышчшЁєхь ухэхЁрЄюЁ ёыєўрщэ√ї ўшёхы
// хёыш эрфю фы  яЁшыюцхэш , фхырЄ№ ¤Єю т kos_Main()
//rtlSrand( kos_GetSystemClock() );
// т√чют уыртэющ ЇєэъЎшш яЁшыюцхэш 
kos_Main();
// т√їюф
kos_ExitApp();
}
@@ -1,217 +0,0 @@
#pragma once
typedef unsigned __int32 Dword;
typedef unsigned __int16 Word;
typedef unsigned __int8 Byte;
//typedef unsigned __int32 size_t;
extern "C" char kosCmdLine[]; // command line initialized by OS
extern "C" char kosExePath[]; // path to binary initialized by OS
#define NULL 0
#define MAX_PATH 256
#define FO_READ 0
#define FO_WRITE 2
#define EM_WINDOW_REDRAW 1
#define EM_KEY_PRESS 2
#define EM_BUTTON_CLICK 4
#define EM_APP_CLOSE 8
#define EM_DRAW_BACKGROUND 16
#define EM_MOUSE_EVENT 32
#define EM_IPC 64
#define EM_NETWORK 256
#define KM_CHARS 0
#define KM_SCANS 1
#define WRS_BEGIN 1
#define WRS_END 2
#define PROCESS_ID_SELF -1
#define abs(a) (a<0?0-a:a)
extern "C" double __cdecl acos(double x);
extern "C" double __cdecl asin(double x);
extern "C" double __cdecl floor(double x);
extern "C" double __cdecl round(double x);
#pragma function(acos,asin)
#if _MSC_VER > 1200
#pragma function(floor)
#endif
struct kosFileInfo
{
Dword rwMode;
Dword OffsetLow;
Dword OffsetHigh;
Dword dataCount;
Byte *bufferPtr;
char fileURL[MAX_PATH];
};
struct RGB
{
Byte b;
Byte g;
Byte r;
//
RGB() {};
//
RGB( Dword value )
{
r = (Byte)(value >> 16);
g = (Byte)(value >> 8);
b = (Byte)value;
};
//
bool operator != ( RGB &another )
{
return this->b != another.b || this->g != another.g || this->r != another.r;
};
//
bool operator == ( RGB &another )
{
return this->b == another.b && this->g == another.g && this->r == another.r;
};
};
#pragma pack(push, 1)
union sProcessInfo
{
Byte rawData[1024];
struct
{
Dword cpu_usage;
Word window_stack_position;
Word window_stack_value;
Word reserved1;
char process_name[12];
Dword memory_start;
Dword used_memory;
Dword PID;
Dword x_start;
Dword y_start;
Dword x_size;
Dword y_size;
Word slot_state;
} processInfo;
};
#pragma pack(pop)
//
extern "C" void __cdecl crtStartUp();
//
int __cdecl _purecall();
//
int __cdecl atexit( void (__cdecl *func )( void ));
//
void rtlSrand( Dword seed );
Dword rtlRand( void );
//
char * __cdecl strcpy( char *target, const char *source );
int __cdecl strlen( const char *line );
char * __cdecl strrchr( const char * string, int c );
#if _MSC_VER < 1400
extern "C" void * __cdecl memcpy( void *dst, const void *src, size_t bytesCount );
extern "C" void memset( Byte *dst, Byte filler, Dword count );
//#pragma intrinsic(memcpy,memset)
#else
void * __cdecl memcpy( void *dst, const void *src, size_t bytesCount );
void memset( Byte *dst, Byte filler, Dword count );
#endif
unsigned int num2hex( unsigned int num );
void sprintf( char *Str, char* Format, ... );
//
Dword rtlInterlockedExchange( Dword *target, Dword value );
// ЇєэъЎш  -1 чртхЁ°хэш  яЁюЎхёёр
void __declspec(noreturn) kos_ExitApp();
// ЇєэъЎш  0
void kos_DefineAndDrawWindow(
Word x, Word y,
Word sizeX, Word sizeY,
Byte mainAreaType, Dword mainAreaColour,
Byte headerType, Dword headerColour,
Dword borderColour
);
// ЇєэъЎш  1 яюёЄртшЄ№ Єюўъє
void kos_PutPixel( Dword x, Dword y, Dword colour );
// ЇєэъЎш  2 яюыєўшЄ№ ъюф эрцрЄющ ъыртш°ш
bool kos_GetKey( Byte &keyCode );
// ЇєэъЎш  3 яюыєўшЄ№ тЁхь 
Dword kos_GetSystemClock();
// ЇєэъЎш  4
void kos_WriteTextToWindow(
Word x, Word y,
Byte fontType,
Dword textColour,
const char *textPtr,
Dword textLen
);
// ЇєэъЎш  7 эрЁшёютрЄ№ шчюсЁрцхэшх
void kos_PutImage( RGB * imagePtr, Word sizeX, Word sizeY, Word x, Word y );
// ЇєэъЎш  8 юяЁхфхышЄ№ ъэюяъє
void __declspec(noinline) kos_DefineButton( Word x, Word y, Word sizeX, Word sizeY, Dword buttonID, Dword colour );
// ЇєэъЎш  5 ярєчр, т ёюЄ√ї фюы ї ёхъєэф√
void kos_Pause( Dword value );
// ЇєэъЎш  9 - шэЇюЁьрЎш  ю яЁюЎхёёх
Dword kos_ProcessInfo( sProcessInfo *targetPtr, Dword processID = PROCESS_ID_SELF );
// ЇєэъЎш  10
Dword kos_WaitForEvent();
// ЇєэъЎш  11
Dword kos_CheckForEvent();
// ЇєэъЎш  12
void kos_WindowRedrawStatus( Dword status );
// ЇєэъЎш  13 эрЁшёютрЄ№ яюыюёє
void __declspec(noinline) kos_DrawBar( Word x, Word y, Word sizeX, Word sizeY, Dword colour );
// ЇєэъЎш  17
bool kos_GetButtonID( Dword &buttonID );
// ЇєэъЎш  23
Dword kos_WaitForEventTimeout( Dword timeOut );
//
enum eNumberBase
{
nbDecimal = 0,
nbHex,
nbBin
};
// яюыєўхэшх шэЇюЁьрЎшш ю ёюёЄю эшш "ь√°ш" ЇєэъЎш  37
void kos_GetMouseState( Dword & buttons, int & cursorX, int & cursorY );
// ЇєэъЎш  40 єёЄрэютшЄ№ ьрёъє ёюс√Єшщ
void kos_SetMaskForEvents( Dword mask );
// ЇєэъЎш  47 т√тхёЄш т юъэю яЁшыюцхэш  ўшёыю
void kos_DisplayNumberToWindow(
Dword value,
Dword digitsNum,
Word x,
Word y,
Dword colour,
eNumberBase nBase = nbDecimal,
bool valueIsPointer = false
);
// ЇєэъЎш  58 фюёЄєя ъ Їрщыютющ ёшёЄхьх
Dword kos_FileSystemAccess( kosFileInfo *fileInfo );
// ЇєэъЎш  63
void kos_DebugOutChar( char ccc );
//
void rtlDebugOutString( char *str );
// ЇєэъЎш  64 шчьхэшЄ№ ярЁрьхЄЁ√ юъэр, ярЁрьхЄЁ == -1 эх ьхэ хЄё 
void kos_ChangeWindow( Dword x, Dword y, Dword sizeX, Dword sizeY );
// ЇєэъЎш  67 шчьхэхэшх ъюышўхёЄтр ярь Єш, т√фхыхээющ фы  яЁюуЁрьь√
bool kos_ApplicationMemoryResize( Dword targetSize );
// ЇєэъЎш  66 Ёхцшь яюыєўхэш  фрээ√ї юЄ ъыртшрЄєЁ√
void kos_SetKeyboardDataMode( Dword mode );
void kos_InitHeap();
//
void kos_Main();
@@ -1,83 +0,0 @@
#include <math.h>
#include "kosSyst.h"
extern "C" int _fltused = 0;
double __cdecl acos(double x)
{
__asm {
fld qword ptr [esp+4]
fld1
fadd st, st(1)
fld1
fsub st, st(2)
fmulp st(1), st
fsqrt
fxch st(1)
fpatan
}
}
double __cdecl asin(double x)
{
__asm {
fld qword ptr [esp+4]
fld1
fadd st, st(1)
fld1
fsub st, st(2)
fmulp st(1), st
fsqrt
fpatan
ret
}
}
#if _MSC_VER <= 1200
extern "C" double _ftol(double x)
{
__asm {
fld qword ptr [esp+4]
push 1F3Fh
fstcw word ptr [esp+2]
fldcw word ptr [esp]
frndint
fldcw word ptr [esp+2]
add esp, 4
}
}
#endif
double __cdecl ceil(double x)
{
__asm {
fld qword ptr [esp+4]
push 1B3Fh
fstcw word ptr [esp+2]
fldcw word ptr [esp]
frndint
fldcw word ptr [esp+2]
add esp, 4
}
}
double __cdecl floor(double x)
{
__asm {
fld qword ptr [esp+4]
push 173Fh
fstcw word ptr [esp+2]
fldcw word ptr [esp]
frndint
fldcw word ptr [esp+2]
add esp, 4
}
}
double __cdecl round(double x)
{
__asm {
fld qword ptr [esp+4]
push 133Fh
fstcw word ptr [esp+2]
fldcw word ptr [esp]
frndint
fldcw word ptr [esp+2]
add esp, 4
}
}
@@ -1,373 +0,0 @@
// memman.cpp : Defines the entry point for the console application.
//
#include "kosSyst.h"
#include "mcsmemm.h"
void * __cdecl operator new ( size_t count, size_t element_size )
{
return allocmem( (Dword)(count * element_size) );
}
void * __cdecl operator new [] ( size_t amount )
{
return allocmem( (Dword)amount );
}
void * __cdecl operator new ( size_t amount )
{
return allocmem( (Dword)amount );
}
void __cdecl operator delete ( void *pointer )
{
if ( pointer != NULL ) freemem( pointer );
}
void __cdecl operator delete [] ( void *pointer )
{
if ( pointer != NULL ) freemem( pointer );
}
void __cdecl initHeap(void)
{
__asm
{
push 68
pop eax
push 11
pop ebx
int 0x40
}
}
#pragma data_seg(".CRT$XCB")
__declspec(allocate(".CRT$XCB")) void (__cdecl *initHeapPtr)(void) = &initHeap;
__declspec(noinline) Byte* __fastcall allocmem( Dword reqsize )
{
initHeapPtr; // force dependency
__asm
{
push 68
pop eax
push 12
pop ebx
int 0x40
}
}
__declspec(noinline) void __fastcall freemem( void *vaddress )
{
initHeapPtr; // force dependency
__asm
{
push 68
pop eax
push 13
pop ebx
int 0x40
}
}
/*
//
Dword mmMutex = FALSE;
MemBlock *rootfree = NULL;
MemBlock *rootuser = NULL;
bool mmInitialized = false;
Byte *mmHeapTop = NULL;
//
Byte * AllocMemFromSystem( Dword reqSize )
{
Byte *result;
sProcessInfo pInfo;
//
if ( mmInitialized )
{
result = mmHeapTop;
}
else
{
//
kos_ProcessInfo( &pInfo );
//
result = (Byte *)(pInfo.processInfo.used_memory + 1);
//
mmInitialized = true;
}
//
if ( ! kos_ApplicationMemoryResize( ((Dword)result) + reqSize ) )
{
result = NULL;
}
//
mmHeapTop = result + reqSize;
//
return result;
}
//
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 *)AllocMemFromSystem( reqsize + sizeof(MemBlock) );
//
if( LastKnownGood != NULL )
{
LastKnownGood->Size = reqsize;
//ЄхяхЁ№ тёЄртшь хую т юўхЁхф№ чрэ Є√ї
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;
}
}
// юЄяєёЄшь ь№■Єхъё
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;
}
*/
@@ -1,28 +0,0 @@
//
struct MemBlock
{
Dword Size;
Dword Addr;
MemBlock *Next;
MemBlock *Previous;
};
#define INITIALQUEUESIZE (32 * 4)
#define FALSE 0
#define TRUE -1
#define MB_FREE 0
#define MB_USER 1
#define SIZE_ALIGN 4
Byte * __fastcall allocmem( Dword reqsize );
void __fastcall freemem( void *vaddress );
@@ -1,95 +0,0 @@
/* Rocket Forces
* Filename: mymath.h
* Version 0.1
* Copyright (c) Serial 2007
*/
extern "C" int _fltused = 0;
#define M_PI 3.14159265358979323846
inline double sin(double x)
{
__asm fld x
__asm fsin
}
inline double cos(double x)
{
__asm fld x
__asm fcos
}
inline double sqrt(double x)
{
__asm fld x
__asm fsqrt
}
inline double acos(double x)
{
__asm fld x
__asm fld st(0)
__asm fmul st,st(1)
__asm fld1
__asm fsubrp st(1),st(0)
__asm fsqrt
__asm fxch st(1)
__asm fpatan
}
inline double atan(double x)
{
double res = acos(1 / sqrt(1 + x * x));
if (x < 0)
{
res *= -1;
}
return res;
}
inline int round_int(double x)
{
int i;
static const float round_to_nearest = 0.5f;
__asm
{
fld x
fadd st, st(0)
fadd round_to_nearest
fistp i
sar i, 1
}
return i;
}
inline int floor_int(double x)
{
int i;
static const float round_toward_m_i = -0.5f;
__asm
{
fld x
fadd st, st (0)
fadd round_toward_m_i
fistp i
sar i, 1
}
return i;
}
inline int ceil_int(double x)
{
int i;
static const float round_toward_p_i = -0.5f;
__asm
{
fld x
fadd st, st (0)
fsubr round_toward_p_i
fistp i
sar i, 1
}
return (-i);
}
@@ -1,11 +0,0 @@
#include "kosSyst.h"
static char pureCallMessage[] = "PURE function call!";
// т√чют рсёЄЁръЄэюую ьхЄюфр
int __cdecl _purecall()
{
rtlDebugOutString( pureCallMessage );
kos_ExitApp();
return 0;
}
@@ -1,72 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{0D291390-1953-4E1F-BBE2-57F12AFF3214}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>smalllibc</RootNamespace>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup />
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MinSpace</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<BufferSecurityCheck>false</BufferSecurityCheck>
<OmitFramePointers>true</OmitFramePointers>
<FavorSizeOrSpeed>Size</FavorSizeOrSpeed>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClInclude Include="func.h" />
<ClInclude Include="kosFile.h" />
<ClInclude Include="kosSyst.h" />
<ClInclude Include="mcsmemm.h" />
<ClInclude Include="mymath.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="func.cpp" />
<ClCompile Include="kosFile.cpp" />
<ClCompile Include="kosSyst.cpp" />
<ClCompile Include="math2.cpp" />
<ClCompile Include="mcsmemm.cpp" />
<ClCompile Include="purecall.cpp" />
<ClCompile Include="sprintf.cpp" />
</ItemGroup>
<ItemGroup>
<Object Include="init.obj" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
@@ -1,60 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Файлы исходного кода">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Заголовочные файлы">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
<Filter Include="Файлы ресурсов">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="func.h">
<Filter>Заголовочные файлы</Filter>
</ClInclude>
<ClInclude Include="kosFile.h">
<Filter>Заголовочные файлы</Filter>
</ClInclude>
<ClInclude Include="kosSyst.h">
<Filter>Заголовочные файлы</Filter>
</ClInclude>
<ClInclude Include="mcsmemm.h">
<Filter>Заголовочные файлы</Filter>
</ClInclude>
<ClInclude Include="mymath.h">
<Filter>Заголовочные файлы</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="func.cpp">
<Filter>Файлы исходного кода</Filter>
</ClCompile>
<ClCompile Include="kosFile.cpp">
<Filter>Файлы исходного кода</Filter>
</ClCompile>
<ClCompile Include="kosSyst.cpp">
<Filter>Файлы исходного кода</Filter>
</ClCompile>
<ClCompile Include="math2.cpp">
<Filter>Файлы исходного кода</Filter>
</ClCompile>
<ClCompile Include="mcsmemm.cpp">
<Filter>Файлы исходного кода</Filter>
</ClCompile>
<ClCompile Include="sprintf.cpp">
<Filter>Файлы исходного кода</Filter>
</ClCompile>
<ClCompile Include="purecall.cpp">
<Filter>Файлы исходного кода</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<Object Include="init.obj" />
</ItemGroup>
</Project>
@@ -1,228 +0,0 @@
#include "kosSyst.h"
#include "func.h"
#include <stdarg.h>
//////////////////////////////////////////////////////////////////////
//
// т√тюф ёЄЁюъш эр яхўрЄ№. barsuk фюсртшы %f
//#define PREC 2
//#define HALF 0.499
#define PREC 6
#define HALF 0.4999999
static double double_tab[]={1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29, 1e30};
//
static Dword dectab[] = { 1000000000, 100000000, 10000000, 1000000, 100000,
10000, 1000, 100, 10, 0 };
//
void sprintf( char *Str, char* Format, ... )
{
int i, fmtlinesize, j, k, flag;
Dword head, tail;
char c;
va_list arglist;
//
va_start(arglist, Format);
//
fmtlinesize = strlen( Format );
//
if( fmtlinesize == 0 ) return;
//
for( i = 0, j = 0; i < fmtlinesize; i++ )
{
//
c = Format[i];
//
if( c != '%' )
{
Str[j++] = c;
continue;
}
//
i++;
//
if( i >= fmtlinesize ) break;
//
flag = 0;
//
c = Format[i];
//
switch( c )
{
//
case '%':
Str[j++] = c;
break;
// т√тюф ёЄЁюъш
case 'S':
Byte* str;
str = va_arg(arglist, Byte*);
for( k = 0; ( c = str[k] ) != 0; k++ )
{
Str[j++] = c;
}
break;
// т√тюф срщЄр
case 'B':
k = va_arg(arglist, int) & 0xFF;
Str[j++] = num2hex( ( k >> 4 ) & 0xF );
Str[j++] = num2hex( k & 0xF );
break;
// т√тюф ёшьтюыр
case 'C':
Str[j++] = va_arg(arglist, int) & 0xFF;
break;
// т√тюф фтющэюую ёыютр т °хёЄэрфЎрЄшЁшўэюь тшфх
case 'X':
Dword val;
val = va_arg(arglist, Dword);
for( k = 7; k >= 0; k-- )
{
//
c = num2hex ( ( val >> (k * 4) ) & 0xF );
//
if( c == '0' )
{
if( flag ) Str[j++] = c;
}
else
{
flag++;
Str[j++] = c;
}
}
//
if( flag == 0 ) Str[j++] = '0';
break;
// т√тюф фтющэюую ёыютр т фхё Єшўэюь тшфх
case 'U':
head = va_arg(arglist, Dword);
tail = 0;
for( k = 0; dectab[k] != 0; k++ )
{
tail = head % dectab[k];
head /= dectab[k];
c = head + '0';
if( c == '0' )
{
if( flag ) Str[j++] = c;
}
else
{
flag++;
Str[j++] = c;
}
//
head = tail;
}
//
c = head + '0';
Str[j++] = c;
break;
// тх∙хёЄтхээюх ўшёыю т ЇюЁьрЄх 7.2
case 'f':
case 'F':
case 'g':
case 'G':
{
double val, w;
int p;
val = va_arg(arglist, double);
if (val < 0.0)
{
Str[j++] = '-';
val = -val;
}
for (k = 0; k < 30; k++)
if (val < double_tab[k])
break;
if (val < 1.0)
{
Str[j++] = '0';
}
for (p = 1; p < k + 1; p++)
{
int d = (int)di(val / double_tab[k - p] - HALF) % 10;
Str[j++] = '0' + d;
val -= d * double_tab[k - p];
}
Str[j++] = '.';
w = 0.1;
for (p = 0; p < PREC - 1; p++)
{
val-=floor(val);
Str[j++] = '0' + di(val / w - HALF) % 10;
w /= 10.0;
}
}
break;
// т√тюф 64-сшЄэюую ёыютр т °хёЄэрфЎрЄшЁшўэюь тшфх
case 'Q':
unsigned int low_dword, high_dword;
low_dword = va_arg(arglist, unsigned int);
high_dword = va_arg(arglist, unsigned int);
for( k = 7; k >= 0; k-- )
{
//
c = num2hex ( ( ( high_dword + 1) >> (k * 4) ) & 0xF );
//
if( c == '0' )
{
if( flag ) Str[j++] = c;
}
else
{
flag++;
Str[j++] = c;
}
}
//
for( k=7; k >= 0; k-- )
{
//
c = num2hex ( ( low_dword >> (k * 4) ) & 0xF );
//
if( c == '0' )
{
if( flag ) Str[j++] = c;
}
else
{
flag++;
Str[j++] = c;
}
}
//
if( flag == 0 ) Str[j++] = '0';
//
break;
//
default:
break;
}
}
//
Str[j] = 0;
}
char *ftoa(double d)
{
char buffer[256], *p;
sprintf(buffer, "%f", d);
p = (char*)allocmem(strlen(buffer)+1);
strcpy(p, buffer);
return p;
}
+25
View File
@@ -0,0 +1,25 @@
## Floppy Bird for KolibriOS
Simple clone of world-famous Flappy Bird game for KolibriOS, written in C.
### Links
* [Forum topic](http://board.kolibrios.org/viewtopic.php?t=4471)
### Controls
* Main menu:
* 1 - fast game mode
* 2 - slow game mode
* Game:
* Space - jump
* Game over:
* Space - restart
* Escape - return to main menu
### Authors
* zorggish - initial author, all game code
* Burer - rewrite to C, some tweaks
<img src="https://i.ibb.co/JW3MCHmM/showcase.png" alt="Showcase" width="100%">
+12
View File
@@ -0,0 +1,12 @@
if tup.getconfig("NO_TCC") ~= "" then return end
if tup.getconfig("HELPERDIR") == ""
then
HELPERDIR = "../../../programs"
end
tup.include(HELPERDIR .. "/use_tcc.lua")
SRCS = {
"flpybird.c"
}
link_tcc(SRCS, "flpybird");
+352
View File
@@ -0,0 +1,352 @@
// SPDX-License-Identifier: GPL-2.0-only
//
// Floppy Bird - Infinite flopping game
// Copyright (C) 2021-2025 KolibriOS team
//
// Contributor zorggish - Main code
// Contributor Burer - Rewrite to C
#include <sys/ksys.h>
#include "images.h"
/* ===== Global const strings ===== */
static const char HEADER_STRING[] = "Floppy Bird";
static const char CONTROL_STRING[] = "SPACEBAR TO JUMP";
static const char GAMEOVER_STRING[] = "GAME OVER";
static const char SPA_KEY_STRING[] = "PRESS SPACEBAR FOR RESTART";
static const char ESC_KEY_STRING[] = "PRESS ESCAPE FOR MENU";
static const char FAST_STRING[] = "1 - FAST";
static const char SLOW_STRING[] = "2 - SLOW";
/* ===== Global window variables ===== */
#define WIN_W 400
#define WIN_H 376
#define WIN_B 5
#define WIN_S 10
static int WIN_X;
static int WIN_Y;
static int WIN_T;
/* ===== Global game variables ===== */
#define GAMESTATE_MENU 0
#define GAMESTATE_STARTED 1
#define GAMESTATE_GAMEOVER 2
static int game_rng;
static int game_speed = 1;
static int game_pause = 0;
static char game_score[] = "Score: 000";
static int game_state;
/* ===== Bird ===== */
#define BIRD_W 19
#define BIRD_H 20
#define BIRD_X 100
static int bird_pos;
static int bird_acc;
static void Bird_initialize(void) {
bird_pos = (WIN_H + WIN_T) / 2;
bird_acc = 0;
}
static void Bird_move(void) {
bird_acc += (bird_acc <= 30) * 2; // 2 or 0
bird_pos += bird_acc / 10;
}
static void Bird_jump(void) {
bird_acc = -50;
}
/* ===== Tube ===== */
#define TUBE_WIDTH 50
#define TUBE_GAPHEIGHT 100
#define TUBE_HEADHEIGHT 18
#define tube_num 3
static int tube_pos[tube_num];
static int tube_gap[tube_num];
static void Tube_randomize(int t) {
int x = game_rng; x ^= x << 13; x ^= x >> 17; x ^= x << 5; game_rng = x;
int r = x & 255u;
if (r >= WIN_H / 2)
r -= 256 - WIN_H / 2;
tube_pos[t] = WIN_W + 1;
tube_gap[t] = r + (WIN_H / 2 - TUBE_GAPHEIGHT - WIN_B) / 2;
}
static void Tube_move(int t) {
tube_pos[t] -= 2;
if (tube_pos[t] < -TUBE_WIDTH - 2)
Tube_randomize(t);
}
static void Tube_draw(int t) {
/* cleanup */
int pixels = WIN_W - WIN_S - TUBE_WIDTH - tube_pos[t];
if (pixels > 0) {
if (pixels > 2)
pixels = 2;
_ksys_draw_bar(tube_pos[t] + TUBE_WIDTH, tube_gap[t] - TUBE_HEADHEIGHT, pixels, TUBE_HEADHEIGHT, GAME_PALETTE[0]);
_ksys_draw_bar(tube_pos[t] + TUBE_WIDTH, tube_gap[t] + TUBE_GAPHEIGHT , pixels, TUBE_HEADHEIGHT, GAME_PALETTE[0]);
}
if (tube_pos[t] < 0) {
int w = -tube_pos[t];
if (w > 2)
w = 2;
_ksys_draw_bar(0, tube_gap[t] - TUBE_HEADHEIGHT, w, TUBE_HEADHEIGHT, GAME_PALETTE[0]);
_ksys_draw_bar(0, tube_gap[t] + TUBE_GAPHEIGHT , w, TUBE_HEADHEIGHT, GAME_PALETTE[0]);
}
int offset = tube_pos[t] >= 0 ? 0 : -tube_pos[t];
int trim = (tube_pos[t] + TUBE_WIDTH >= WIN_W - WIN_S)
? WIN_W - tube_pos[t] - TUBE_WIDTH - WIN_S : 0;
if (offset >= TUBE_WIDTH + trim)
return;
/* top */
for (int y = 0; y < tube_gap[t] - TUBE_HEADHEIGHT; ++y)
ksys_draw_bitmap_palette(
TUBE_BODY_IMAGE + offset,
tube_pos[t] + offset, y, TUBE_WIDTH - offset + trim, 1, 8, GAME_PALETTE, 0
);
/* head top */
for (int y = tube_gap[t] - TUBE_HEADHEIGHT; y < tube_gap[t]; ++y)
ksys_draw_bitmap_palette(
TUBE_HEAD_IMAGE + TUBE_WIDTH * (y - tube_gap[t] + TUBE_HEADHEIGHT) + offset,
tube_pos[t] + offset, y, TUBE_WIDTH - offset + trim, 1, 8, GAME_PALETTE, 0
);
/* head down */
for (int y = tube_gap[t] + TUBE_GAPHEIGHT; y < tube_gap[t] + TUBE_GAPHEIGHT + TUBE_HEADHEIGHT; ++y)
ksys_draw_bitmap_palette(
TUBE_HEAD_IMAGE + TUBE_WIDTH * (y - tube_gap[t] - TUBE_GAPHEIGHT) + offset,
tube_pos[t] + offset, y, TUBE_WIDTH - offset + trim, 1, 8, GAME_PALETTE, 0
);
/* down */
for (int y = tube_gap[t] + TUBE_GAPHEIGHT + TUBE_HEADHEIGHT; y < WIN_H - WIN_B; ++y)
ksys_draw_bitmap_palette(
TUBE_BODY_IMAGE + offset,
tube_pos[t] + offset, y, TUBE_WIDTH - offset + trim, 1, 8, GAME_PALETTE, 0
);
}
/* ===== Functions - Helpers ===== */
static void WriteBorderedText(int x, int y, const char* textPtr, int textLen, int fontType) {
for (int bx = x + 2; bx >= x - 2; --bx) {
for (int by = y + 2; by >= y - 2; --by) {
_ksys_draw_text(textPtr, bx, by, textLen, fontType);
}
}
_ksys_draw_text(textPtr, x, y, textLen, fontType | 0x00FFFFFF);
}
/* ===== Functions - Game Logic ===== */
static inline int checkCollision(int t) {
return ((tube_pos[t] <= (BIRD_X + BIRD_W) && tube_pos[t] + TUBE_WIDTH >= BIRD_X)
&& (bird_pos <= tube_gap[t] || bird_pos + BIRD_H >= tube_gap[t] + TUBE_GAPHEIGHT)) ? 1 : 0;
}
static inline int checkAddScore(int t) {
int r = tube_pos[t] + TUBE_WIDTH;
return (r + 2 >= BIRD_X) & (r < BIRD_X);
}
static void updateScoreString(void) {
for (int i = 9; i >= 6; --i) {
if (++game_score[i] <= '9') return;
game_score[i] = '0';
}
}
/* ===== Functions - Game Drawing ===== */
static inline void createGameWindow(void) {
_ksys_create_window(WIN_X, WIN_Y, WIN_W, WIN_H + WIN_T, HEADER_STRING, GAME_PALETTE[0], 0x34);
}
static void redrawGameWindow(void) {
/* cleaning the score area */
int move = bird_acc / 10;
if (move < 0)
move = -move;
_ksys_draw_bar(BIRD_X, bird_pos - move, BIRD_W, move * 2 + BIRD_H, GAME_PALETTE[0]);
ksys_draw_bitmap_palette(BIRD_IMAGE, BIRD_X, bird_pos, BIRD_W, BIRD_H, 8, GAME_PALETTE, 0);
Tube_draw(0); Tube_draw(1); Tube_draw(2);
WriteBorderedText(10, 10, game_score, 0, 0x81000000);
}
static void drawGameOverWindow(void) {
createGameWindow();
WriteBorderedText(116, 100, GAMEOVER_STRING, 0, 0x82000000);
WriteBorderedText(136, 157, game_score, 0, 0x81000000);
WriteBorderedText( 40, 207, SPA_KEY_STRING, 0, 0x81000000);
WriteBorderedText( 70, 241, ESC_KEY_STRING, 0, 0x81000000);
}
static void drawMenuWindow(void) {
createGameWindow();
WriteBorderedText( 88, 34, HEADER_STRING, 6, 0x04000000);
WriteBorderedText(188, 87, HEADER_STRING + 7, 4, 0x04000000);
char* pos = &TUBE_HEAD_IMAGE[0];
for (int x = 50 - 1; x >= 50 - TUBE_HEADHEIGHT; --x) {
for (int y = 156; y < 156 + TUBE_WIDTH; ++y) {
ksys_draw_bitmap_palette(pos, x, y , 1, 1, 8, GAME_PALETTE, 0);
ksys_draw_bitmap_palette(pos, x, y + 82, 1, 1, 8, GAME_PALETTE, 0);
++pos;
}
}
for (int x = 50; x < WIN_W - WIN_S; ++x)
{
ksys_draw_bitmap_palette(TUBE_BODY_IMAGE, x, 156, 1, TUBE_WIDTH, 8, GAME_PALETTE, 0);
ksys_draw_bitmap_palette(TUBE_BODY_IMAGE, x, 238, 1, TUBE_WIDTH, 8, GAME_PALETTE, 0);
}
WriteBorderedText(139, 171, FAST_STRING, 0, 0x82000000);
WriteBorderedText(139, 253, SLOW_STRING, 0, 0x82000000);
// Control hint
WriteBorderedText(100, 322, CONTROL_STRING, 0, 0x81000000);
}
/* ===== Functions - Game Main ===== */
static void startGame(void) {
createGameWindow();
game_score[7] = game_score[8] = game_score[9] = '0';
Bird_initialize();
const int spacing = (WIN_W + TUBE_WIDTH) / 3;
for (int i = tube_num - 1; i >= 0; --i) {
Tube_randomize(i);
tube_pos[i] = WIN_W + i * spacing;
}
game_state = GAMESTATE_STARTED;
}
static void frameGame(void) {
Bird_move();
/* Processing all tubes */
for (int i = tube_num - 1; i >= 0; --i) {
/* Adding score */
if (checkAddScore(i)) {
updateScoreString();
_ksys_draw_bar(92, 8, 38, 18, GAME_PALETTE[0]);
}
/* Check collision with bird */
if (checkCollision(i))
goto game_over;
/* Move tube */
Tube_move(i);
}
/* Checking bird is too high or low */
if (bird_pos + BIRD_H > WIN_H - WIN_B || bird_pos < 0)
goto game_over;
redrawGameWindow();
return;
game_over:
game_state = GAMESTATE_GAMEOVER;
drawGameOverWindow();
return;
}
int main(void) {
/* Setting RNG seed */
ksys_time_t t = _ksys_get_time();
game_rng = (int)t.val | 1u;
/* Centering window */
ksys_pos_t screen = _ksys_screen_size();
WIN_X = (screen.x - WIN_W) / 2;
WIN_Y = (screen.y - WIN_H) / 2;
WIN_T = _ksys_get_skin_height();
game_state = GAMESTATE_MENU;
for (;;) {
_ksys_delay(game_speed);
switch (_ksys_check_event()) {
case KSYS_EVENT_NONE:
if (game_state == GAMESTATE_STARTED)
frameGame();
break;
case KSYS_EVENT_REDRAW: {
switch (game_state) {
case GAMESTATE_MENU: drawMenuWindow(); break;
case GAMESTATE_STARTED: redrawGameWindow(); break;
case GAMESTATE_GAMEOVER: drawGameOverWindow(); break;
}
break;
}
case KSYS_EVENT_KEY: {
ksys_oskey_t k = _ksys_get_key();
switch (game_state) {
case GAMESTATE_MENU: {
unsigned kc = k.code - 49; // 1 or 2
if (kc <= 1) {
game_speed = kc + 1;
startGame();
}
break;
}
case GAMESTATE_STARTED: {
if (k.code == 32) // SPACE
Bird_jump();
break;
}
case GAMESTATE_GAMEOVER: {
if (k.code == 32) // SPACE
startGame();
if (k.code == 27) // ESCAPE
{
game_state = GAMESTATE_MENU;
drawMenuWindow();
}
break;
}
}
break;
}
case KSYS_EVENT_BUTTON:
_ksys_exit();
break;
}
}
return 0;
}
+74
View File
@@ -0,0 +1,74 @@
// SPDX-License-Identifier: GPL-2.0-only
//
// Floppy Bird - Infinite flopping game
// Copyright (C) 2021-2025 KolibriOS team
//
// Contributor zorggish - Main code
// Contributor Burer - Rewrite to C
#pragma once
static const int GAME_PALETTE[77] = {
// Shared colors
0x0000FFFF, 0x00E0E080, 0x00C0C080, 0x0080A040, 0x00A0C040, 0x00A0C080, 0x00A0E040, 0x0060A040,
0x00C0E080,
// Bird-only colors
0x00C08040, 0x00608080, 0x0040C0C0, 0x00E0C080, 0x00806040, 0x00C0DCC0, 0x00A06040, 0x0080C0C0,
0x00E0A040, 0x0020C0C0, 0x00C06040, 0x00C0A080, 0x00A0A080, 0x00800040, 0x00E02080, 0x00E060C0,
0x00808080, 0x00E020C0, 0x00E0A0C0, 0x00804080, 0x00FFFBF0, 0x00E040C0, 0x00002040, 0x00404040,
0x00806080, 0x00A08080, 0x00E0E000, 0x00A0A0A4, 0x0020A080, 0x0040A0C0, 0x0060C0C0, 0x00E0C040,
0x00C00080, 0x00FFFF00, 0x00C0A040, 0x0060A080, 0x0080A080, 0x00C0C0C0, 0x00E0E040, 0x00C0E000,
0x0080E080, 0x00A0A040, 0x0040C080, 0x0060E080, 0x00606080, 0x00C0C040, 0x00C0C000, 0x00808040,
0x00C0E040, 0x00A0C000, 0x006080C0, 0x00A0C0C0, 0x00A0E080,
// Tube-only colors
0x00000000, 0x00608040,
0x0080E040, 0x0080C040, 0x0060A000, 0x0040A000, 0x00408000, 0x00204000, 0x00206000, 0x00200040,
0x00402000, 0x00608000, 0x00406000, 0x0060C000, 0x00402040
};
static const char BIRD_IMAGE[380] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 10, 0, 0, 0, 0, 0, 0, 0,
11, 0, 0, 0, 0, 0, 0, 9, 12, 9, 12, 13, 0, 0, 0, 0, 0, 0, 14, 15,
16, 0, 0, 0, 0, 16, 17, 1, 12, 1, 13, 0, 0, 0, 0, 0, 0, 9, 12, 15,
18, 0, 0, 0, 19, 12, 20, 20, 21, 13, 0, 0, 0, 0, 0, 0, 9, 12, 1, 15,
18, 0, 0, 15, 9, 22, 22, 23, 24, 11, 0, 0, 0, 0, 0, 15, 9, 1, 14, 15,
18, 18, 19, 25, 23, 26, 23, 27, 28, 11, 0, 0, 0, 0, 9, 17, 12, 1, 29, 13,
19, 14, 22, 30, 30, 31, 1, 21, 32, 32, 33, 33, 34, 15, 17, 9, 12, 29, 14, 15,
14, 26, 12, 12, 1, 35, 36, 20, 37, 38, 38, 39, 18, 15, 17, 9, 40, 29, 2, 3,
41, 42, 42, 1, 43, 21, 44, 0, 0, 0, 0, 0, 45, 9, 17, 17, 12, 29, 46, 40,
47, 48, 2, 21, 46, 0, 0, 0, 0, 0, 0, 11, 45, 17, 12, 40, 1, 49, 48, 1,
1, 1, 20, 0, 0, 0, 0, 0, 0, 0, 0, 11, 15, 4, 50, 5, 48, 48, 1, 1,
1, 1, 51, 0, 0, 0, 0, 0, 52, 14, 0, 16, 53, 53, 6, 48, 35, 1, 1, 1,
54, 7, 0, 0, 0, 0, 0, 8, 55, 35, 14, 3, 6, 4, 48, 1, 1, 1, 48, 55,
7, 0, 0, 0, 0, 0, 36, 21, 6, 48, 45, 4, 48, 47, 1, 1, 48, 6, 56, 18,
0, 0, 0, 0, 0, 8, 35, 21, 45, 4, 47, 47, 47, 57, 48, 6, 56, 5, 0, 0,
0, 0, 0, 0, 45, 58, 48, 6, 4, 48, 48, 48, 48, 6, 3, 16, 0, 0, 0, 0,
0, 0, 0, 58, 59, 4, 48, 48, 48, 48, 4, 3, 56, 60, 0, 0, 0, 0, 0, 0,
0, 0, 45, 5, 48, 6, 57, 56, 56, 56, 60, 18, 0, 0, 0, 0, 0, 0, 0, 0,
0, 61, 56, 50, 56, 56, 16, 60, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
static const char TUBE_BODY_IMAGE[50] = {
0, 0, 62, 63, 64, 1, 6, 6, 65, 65, 65, 65, 64, 66, 66, 64, 64, 66, 67, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 67, 66, 68, 68, 69, 66, 68, 68, 69, 70, 69, 71, 0, 0
};
static const char TUBE_HEAD_IMAGE[900] = {
71, 71, 71, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 71, 71, 71, 71, 71,
72, 68, 68, 63, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 7, 7, 5, 5, 7, 7, 3, 7, 7, 7, 7, 7, 3, 3, 3, 3, 73, 74, 69, 69, 72,
72, 75, 75, 65, 6, 1, 1, 1, 1, 8, 8, 8, 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 65, 65, 8, 8, 65, 65, 64, 65, 65, 64, 64, 64, 65, 65, 65, 64, 66, 68, 70, 70, 72,
76, 64, 64, 8, 1, 65, 65, 65, 65, 67, 66, 66, 64, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 69, 74, 74, 66, 70, 69, 70, 70, 72,
76, 64, 64, 8, 1, 65, 65, 65, 65, 66, 66, 66, 64, 66, 67, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 70, 74, 74, 66, 70, 70, 70, 70, 72,
76, 64, 64, 8, 1, 65, 65, 65, 65, 66, 66, 66, 64, 66, 67, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 70, 74, 74, 66, 70, 69, 70, 70, 72,
76, 64, 64, 8, 1, 65, 65, 65, 65, 66, 66, 66, 64, 66, 67, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 70, 74, 74, 66, 70, 69, 70, 70, 72,
76, 64, 64, 8, 1, 65, 65, 65, 65, 66, 66, 66, 64, 66, 67, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 70, 74, 74, 66, 70, 69, 70, 70, 72,
76, 64, 64, 8, 1, 65, 65, 65, 65, 66, 66, 66, 64, 66, 67, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 70, 74, 74, 66, 70, 69, 70, 70, 72,
76, 64, 64, 8, 1, 65, 65, 65, 65, 66, 66, 66, 64, 66, 67, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 70, 74, 74, 66, 70, 69, 70, 70, 72,
76, 64, 64, 8, 1, 65, 65, 65, 65, 66, 66, 66, 64, 66, 67, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 70, 74, 74, 66, 70, 69, 70, 70, 72,
76, 64, 64, 8, 1, 65, 65, 65, 65, 66, 66, 66, 64, 66, 67, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 70, 74, 74, 66, 70, 69, 70, 70, 72,
76, 64, 64, 8, 1, 65, 65, 65, 65, 66, 66, 66, 64, 66, 67, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 70, 74, 74, 66, 70, 69, 70, 70, 72,
76, 64, 64, 8, 1, 65, 65, 65, 65, 67, 66, 66, 64, 66, 67, 66, 66, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 66, 70, 74, 74, 66, 70, 69, 70, 70, 72,
76, 64, 64, 8, 1, 64, 64, 64, 64, 66, 75, 75, 6, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 70, 74, 74, 66, 70, 69, 70, 70, 72,
72, 68, 68, 73, 63, 68, 68, 68, 68, 74, 68, 68, 68, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 70, 70, 70, 74, 70, 70, 70, 70, 72,
72, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 70, 70, 72,
71, 71, 71, 71, 62, 62, 62, 62, 62, 62, 62, 62, 62, 71, 71, 62, 62, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71
};