| /programs/games/LaserTank/trunk/LaserTank.cpp |
|---|
| 0,0 → 1,811 |
| #include <kosSyst.h> |
| #include <kosFile.h> |
| #include <sprintf.cpp> |
| #include <func.h> |
| #include "render.h" |
| #include "image.h" |
| #define MODE_MENU 0 |
| #define MODE_LEVELS 1 |
| #define MODE_GAME 2 |
| #define GAME_NONE 0 |
| #define GAME_VICTORY 1 |
| #define GAME_DEFEAT 2 |
| #define MOUSE_LEFT 0 |
| char* header = "Laser Tank"; |
| struct Level |
| { |
| char fileds[16][16]; |
| }; |
| Level *levels; |
| int levelCount = 0; |
| int levelIndex = 0; |
| RGBA img_tank[576]; |
| RGB img_water[576]; |
| RGB img_brick[576]; |
| RGB img_waterbox[576]; |
| RGB img_ground[576]; |
| RGB img_wall[576]; |
| RGB img_finish[576]; |
| RGBA img_box[576]; |
| RGBA img_laser[576]; |
| RGBA img_mirror[576]; |
| RGBA img_mirror90[576]; |
| RGBA img_mirror180[576]; |
| RGBA img_mirror270[576]; |
| RGBA img_mini_mirror[576]; |
| RGBA img_mini_mirror90[576]; |
| RGBA img_mini_mirror180[576]; |
| RGBA img_mini_mirror270[576]; |
| RGBA img_laser1[576]; |
| RGBA img_laser2[576]; |
| RGB img_brick1[576]; |
| RGB img_menu[147456]; |
| RGBA img_explosion[8064]; |
| RGB img_button[7500]; |
| Player player; |
| CKosRender* renderPlayer; |
| CKosImage* objPlayer; |
| CKosRender* renderLaser; |
| CKosImage* objLaser; |
| CKosImage* objLaser1; |
| CKosImage* objLaser2; |
| CKosRender* renderMirror; |
| CKosImage* objMirror; |
| CKosImage* objMirror90; |
| CKosImage* objMirror180; |
| CKosImage* objMirror270; |
| CKosImage* objMiniMirror; |
| CKosImage* objMiniMirror90; |
| CKosImage* objMiniMirror180; |
| CKosImage* objMiniMirror270; |
| CKosRender* renderBox; |
| CKosImage* objBox; |
| CKosRender* renderExplosion; |
| CKosImage* objExplosion; |
| int gameMode = MODE_MENU; |
| int gameStatus = GAME_NONE; |
| void draw_window(); |
| void openLevel(int index); |
| bool CollRecrVsPoint(Point point, Rect rect) |
| { |
| return (point.X > rect.X && point.Y > rect.Y && point.X < rect.X + rect.Width && point.Y < rect.Y + rect.Height); |
| } |
| struct Button |
| { |
| Rect rect; |
| char* caption; |
| Button() {} |
| Button(char* caption, Rect rect) |
| { |
| this->caption = caption; |
| this->rect = rect; |
| } |
| }; |
| Button ToGame("Game", Rect(150, 258, 224, 50)); |
| Button ToExit("Exit", Rect(150, 321, 224, 50)); |
| struct LvlItem |
| { |
| char s; |
| char d; |
| Byte l; |
| }; |
| LvlItem level[16][16]; |
| char GetField(Point position, bool din) |
| { |
| if (din && level[position.Y][position.X].d != ' ') |
| return level[position.Y][position.X].d; |
| return level[position.Y][position.X].s; |
| } |
| RGB* GetImg(Point position, bool din) |
| { |
| switch (GetField(position, din)) |
| { |
| case 's': |
| return (RGB*)img_wall; |
| case '7': |
| renderMirror->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
| objMirror->Draw(Point(0, 0), 0); |
| return renderMirror->buffer; |
| case '9': |
| renderMirror->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
| objMirror90->Draw(Point(0, 0), 0); |
| return renderMirror->buffer; |
| case '3': |
| renderMirror->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
| objMirror180->Draw(Point(0, 0), 0); |
| return renderMirror->buffer; |
| case '1': |
| renderMirror->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
| objMirror270->Draw(Point(0, 0), 0); |
| return renderMirror->buffer; |
| case 'h': |
| case 'g': |
| return (RGB*)img_ground; |
| case 'b': |
| renderBox->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
| objBox->Draw(Point(0, 0), 0); |
| return renderBox->buffer; |
| // return (RGB*)img_box; |
| case 'f': |
| return (RGB*)img_finish; |
| case 'x': |
| return (RGB*)img_brick; |
| case 'w': |
| return (RGB*)img_water; |
| case 'e': |
| return (RGB*)img_waterbox; |
| case 'y': |
| return (RGB*)img_brick1; |
| } |
| return NULL; |
| } |
| void DrawElevent(Point position, bool din) |
| { |
| kos_PutImage(GetImg(position, din), 24, 24, 24 * position.X, 24 * position.Y); |
| } |
| void MoveBox(Point a, Point b) |
| { |
| level[a.Y][a.X].d = ' '; |
| DrawElevent(a, true); |
| if (level[b.Y][b.X].s == 'w') |
| { |
| level[b.Y][b.X].s = 'e'; |
| DrawElevent(b, true); |
| } |
| else |
| { |
| level[b.Y][b.X].d = 'b'; |
| DrawElevent(b, true); |
| } |
| } |
| void animation(Point vector, float angle) |
| { |
| for (int i = 2; i < 23; ++i) |
| { |
| kos_WindowRedrawStatus(1); |
| DrawElevent(player.position, false); |
| DrawElevent(player.position + vector, false); |
| renderPlayer->RenderImg(GetImg(player.position, true), Point(0, 0), 24, 24); |
| objPlayer->Draw(Point(0, 0), angle); |
| renderPlayer->Draw(player.position * 24 + vector * i); |
| if (level[player.position.Y + vector.Y][player.position.X + vector.X].d == 'b') |
| { |
| renderBox->RenderImg(GetImg(player.position, true), Point(0, 0), 24, 24); |
| objBox->Draw(Point(0, 0), 0); |
| renderBox->Draw((player.position + vector) * 24 + vector * i); |
| } |
| kos_WindowRedrawStatus(2); |
| kos_Pause(1); |
| } |
| if (level[player.position.Y + vector.Y][player.position.X + vector.X].d == 'b') |
| MoveBox(player.position + vector, player.position + vector * 2); |
| DrawElevent(player.position, true); |
| DrawElevent(player.position + vector, true); |
| player.position = player.position + vector; |
| //kos_PutImage(GetImg(player.position + vector), 24, 24, 24 * player.position.X, 24 * player.position.Y); |
| renderPlayer->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
| objPlayer->Draw(Point(0, 0), angle); |
| renderPlayer->Draw(player.position * 24); |
| } |
| void DrawLaser(Point position, int frame) |
| { |
| renderLaser->RenderImg(GetImg(position, false), Point(0, 0), 24, 24); |
| switch (frame) |
| { |
| case 1: |
| objLaser->Draw(Point(0, 0), 0, (RGB)0x00FF00); |
| break; |
| case 2: |
| objLaser->Draw(Point(0, 0), 90, (RGB)0x00FF00); |
| break; |
| case 3: |
| objLaser2->Draw(Point(0, 0), 0, (RGB)0x00FF00); |
| break; |
| default: |
| objLaser1->Draw(Point(-1, 0), (float)frame, (RGB)0x00FF00); |
| } |
| renderLaser->Draw(position * 24); |
| level[position.Y][position.X].l = 1; |
| } |
| void PlayerLaser(void) |
| { |
| Point vector = player.vector; |
| Point position = player.position + vector; |
| bool en = true; |
| while (en) |
| { |
| switch (GetField(position, true)) |
| { |
| case 'b': |
| if (position + vector != player.position) |
| switch (GetField(position + vector, true)) |
| { |
| case 'g': |
| case 'w': |
| case 'e': |
| for (int i = 2; i < 23; ++i) |
| { |
| DrawElevent(position, false); |
| DrawElevent(position + vector, true); |
| DrawLaser(position, (vector.X != 0) ? 1 : 2); |
| renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24); |
| objBox->Draw(Point(0, 0), 0); |
| renderBox->Draw((position) * 24 + vector * i); |
| kos_Pause(1); |
| } |
| MoveBox(position, position + vector); |
| } |
| en = false; |
| break; |
| case 'x': |
| for (int i = 0; i < 23; ++i) |
| { |
| if (i == 11 || i == 22) |
| { |
| level[position.Y][position.X].l -= 1; |
| if (level[position.Y][position.X].l == 2) |
| { |
| level[position.Y][position.X].s = 'y'; |
| level[position.Y][position.X].l = 0; |
| } |
| // rtlDebugOutString(ftoa(level[position.Y][position.X].l)); |
| DrawElevent(position, false); |
| } |
| kos_Pause(1); |
| } |
| en = false; |
| break; |
| case 'g': |
| case 'w': |
| case 'y': |
| case 'e': |
| if (player.position == position) |
| { |
| for (int i = 2; i < 23; ++i) |
| kos_Pause(1); |
| for (int y = 0; y < 16; y++) |
| for (int x = 0; x < 16; x++) |
| if (level[y][x].l == 1) |
| { |
| DrawElevent(Point(x, y), true); |
| level[y][x].l = 0; |
| } |
| for (int i = 0; i < 14; ++i) |
| { |
| renderExplosion->RenderImg(GetImg(position, false), Point(0, 0), 24, 24); |
| objExplosion->Draw(Point(0, 0), 0, i); |
| renderExplosion->Draw((position)* 24); |
| kos_Pause(2); |
| } |
| gameStatus = GAME_DEFEAT; |
| draw_window(); |
| return; |
| } |
| else |
| { |
| if (level[position.Y][position.X].l == 1) |
| DrawLaser(position, 3); |
| else |
| DrawLaser(position, (vector.X != 0) ? 1 : 2); |
| } |
| break; |
| case '7': |
| if (vector == Point(-1, 0) || vector == Point(0, -1)) |
| { |
| vector = (vector.Y == -1) ? Point(1, 0) : Point(0, 1); |
| DrawLaser(position, 0); |
| } |
| else |
| { |
| for (int i = 2; i < 23; ++i) |
| kos_Pause(1); |
| en = false; |
| } |
| break; |
| case '9': |
| if (vector == Point(0, -1) || vector == Point(1, 0)) |
| { |
| vector = (vector.Y == -1) ? Point(-1, 0) : Point(0, 1); |
| DrawLaser(position, 90); |
| } |
| else |
| { |
| for (int i = 2; i < 23; ++i) |
| kos_Pause(1); |
| en = false; |
| } |
| break; |
| case '1': |
| if (vector == Point(-1, 0) || vector == Point(0, 1)) |
| { |
| vector = (vector.Y == 1) ? Point(1, 0) : Point(0, -1); |
| DrawLaser(position, 270); |
| } |
| else |
| { |
| for (int i = 2; i < 23; ++i) |
| kos_Pause(1); |
| en = false; |
| } |
| break; |
| case '3': |
| if (vector == Point(1, 0) || vector == Point(0, 1)) |
| { |
| vector = (vector.Y == 1) ? Point(-1, 0) : Point(0, -1); |
| DrawLaser(position, 180); |
| } |
| else |
| { |
| for (int i = 2; i < 23; ++i) |
| kos_Pause(1); |
| en = false; |
| } |
| break; |
| default: |
| for (int i = 2; i < 23; ++i) |
| kos_Pause(1); |
| en = false; |
| } |
| position = position + vector; |
| } |
| for (int y = 0; y < 16; y++) |
| for (int x = 0; x < 16; x++) |
| if (level[y][x].l == 1) |
| { |
| DrawElevent(Point(x, y), true); |
| level[y][x].l = 0; |
| } |
| } |
| void player_move(Point vector, float angle) |
| { |
| if (player.vector == vector) |
| { |
| switch (GetField(player.position + vector, true)) |
| { |
| case 'b': |
| switch (GetField(player.position + vector * 2, true)) |
| { |
| case 'g': |
| case 'w': |
| case 'e': |
| case 'y': |
| animation(vector, angle); |
| return; |
| } |
| break; |
| case 'f': |
| gameStatus = GAME_VICTORY; |
| draw_window(); |
| break; |
| case ' ': |
| case 'x': |
| case 's': |
| case 'w': |
| case '7': |
| case '9': |
| case '3': |
| case '1': |
| break; |
| default: |
| animation(vector, angle); |
| } |
| } |
| else |
| { |
| int cnt; |
| float addAngle; |
| if (player.vector == vector * -1) |
| { |
| cnt = 48; |
| addAngle = 3.5f; |
| } |
| else |
| { |
| cnt = 24; |
| if (player.angle == 270 && angle == 0 || player.angle == 0 && angle == 270) |
| addAngle = (player.angle == 0) ? -3.5f : 3.5f; |
| else |
| addAngle = (angle < player.angle) ? -3.5f : 3.5f; |
| } |
| for (int i = 1; i < cnt - 1; ++i) |
| { |
| player.angle += addAngle; |
| renderPlayer->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
| objPlayer->Draw(Point(0, 0), player.angle); |
| renderPlayer->Draw(player.position * 24); |
| kos_Pause(1); |
| } |
| player.vector = vector; |
| player.angle = angle; |
| renderPlayer->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
| objPlayer->Draw(Point(0, 0), player.angle); |
| renderPlayer->Draw(player.position * 24); |
| } |
| } |
| void SetMode(int mode) |
| { |
| gameMode = mode; |
| draw_window(); |
| } |
| void key_press(int key) |
| { |
| //rtlDebugOutString(ftoa(key)); |
| switch (gameMode) |
| { |
| case MODE_MENU: |
| break; |
| case MODE_LEVELS: |
| break; |
| case MODE_GAME: |
| switch (key) |
| { |
| case 119: // Up |
| case 178: // W |
| if (gameStatus == GAME_NONE) |
| player_move(Point(0, -1), 270); |
| break; |
| case 177: // Down |
| case 115: // S |
| if (gameStatus == GAME_NONE) |
| player_move(Point(0, 1), 90); |
| break; |
| case 176: // Left |
| case 97: // A |
| if (gameStatus == GAME_NONE) |
| player_move(Point(-1, 0), 180); |
| break; |
| case 179: // Right |
| case 100: // D |
| if (gameStatus == GAME_NONE) |
| player_move(Point(1, 0), 0); |
| break; |
| case 32: // Space |
| if (gameStatus == GAME_NONE) |
| PlayerLaser(); |
| break; |
| case 13: |
| if (gameStatus == GAME_VICTORY) |
| openLevel(levelIndex + 1); |
| else |
| if (gameStatus == GAME_DEFEAT) |
| openLevel(levelIndex); |
| break; |
| } |
| break; |
| } |
| } |
| void MousePress(int button, Point position) |
| { |
| //rtlDebugOutString("Mouse"); |
| //rtlDebugOutString(ftoa(position.X)); |
| //rtlDebugOutString(ftoa(position.Y)); |
| switch (gameMode) |
| { |
| case MODE_MENU: |
| if (CollRecrVsPoint(position, ToGame.rect)) |
| SetMode(MODE_GAME); |
| if (CollRecrVsPoint(position, ToExit.rect)) |
| kos_ExitApp(); |
| break; |
| case MODE_LEVELS: |
| break; |
| case MODE_GAME: |
| break; |
| } |
| } |
| void draw_window(void) |
| { |
| kos_WindowRedrawStatus(1); |
| kos_DefineAndDrawWindow(10, 40, 384 + 9, 384 + 25, 0x33, 0x444444, 0, 0, (Dword)header); |
| switch (gameMode) |
| { |
| case MODE_MENU: |
| kos_PutImage((RGB*)img_menu, 384, 384, 0, 0); |
| // kos_PutImage((RGB*)img_button, 150, 50, ToGame.rect.X, ToGame.rect.Y); |
| break; |
| case MODE_LEVELS: |
| break; |
| case MODE_GAME: |
| for (int y = 0; y < 16; y++) |
| for (int x = 0; x < 16; x++) |
| { |
| if (level[y][x].s != ' ') |
| kos_PutImage(GetImg(Point(x, y), true), 24, 24, 24 * x, 24 * y); |
| if (level[y][x].d == 'b') |
| { |
| renderBox->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
| objBox->Draw(Point(0, 0), 0); |
| renderBox->Draw(Point(x, y) * 24); |
| } |
| } |
| switch (gameStatus) |
| { |
| case GAME_NONE: |
| renderPlayer->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
| objPlayer->Draw(Point(0, 0), player.angle); |
| renderPlayer->Draw(player.position * 24); |
| break; |
| case GAME_VICTORY: |
| kos_WriteTextToWindow(30, 10, 0x80, 0xFFFFFF, "VICTORY", 0); |
| break; |
| case GAME_DEFEAT: |
| kos_WriteTextToWindow(30, 10, 0x80, 0xFFFFFF, "DEFEAT", 0); |
| break; |
| } |
| break; |
| } |
| kos_WindowRedrawStatus(2); |
| } |
| void LevelsLoad() |
| { |
| char *cPtr; |
| cPtr = strrchr(kosExePath, '/'); |
| if (cPtr == NULL) |
| { |
| rtlDebugOutString("Invalid path to executable."); |
| return; |
| } |
| cPtr[1] = 0; |
| strcpy(cPtr + 1, "levels.lvl"); |
| CKosFile *file = new CKosFile(kosExePath); |
| Byte block[256]; |
| while (file->Read(block, 256) == 256) |
| { |
| levelCount++; |
| } |
| //levelCount++; |
| rtlDebugOutString(ftoa(levelCount)); |
| levels = new Level[levelCount]; |
| file->Seek(0, SEEK_SET); |
| for (int i = 0; i < levelCount; ++i) |
| { |
| file->Read(block, 256); |
| int k = 0; |
| for (int y = 0; y < 16; y++) |
| for (int x = 0; x < 16; x++) |
| { |
| // if (block[k] != 0) |
| // rtlDebugOutString(ftoa(block[k])); |
| switch (block[k]) |
| { |
| case 0: |
| levels[i].fileds[y][x] = ' '; |
| break; |
| case 1: |
| levels[i].fileds[y][x] = 'w'; |
| break; |
| case 2: |
| levels[i].fileds[y][x] = 'g'; |
| break; |
| case 3: |
| levels[i].fileds[y][x] = 'x'; |
| break; |
| case 4: |
| levels[i].fileds[y][x] = 's'; |
| break; |
| case 5: |
| levels[i].fileds[y][x] = 'b'; |
| break; |
| case 6: |
| levels[i].fileds[y][x] = '7'; |
| break; |
| case 7: |
| levels[i].fileds[y][x] = '9'; |
| break; |
| case 8: |
| levels[i].fileds[y][x] = '3'; |
| break; |
| case 9: |
| levels[i].fileds[y][x] = '1'; |
| break; |
| case 10: |
| levels[i].fileds[y][x] = 'h'; |
| break; |
| case 11: |
| levels[i].fileds[y][x] = 'f'; |
| break; |
| } |
| k++; |
| } |
| } |
| } |
| void openLevel(int index) |
| { |
| levelIndex = index; |
| for (int y = 0; y < 16; y++) |
| for (int x = 0; x < 16; x++) |
| { |
| level[y][x].s = levels[index].fileds[y][x]; |
| level[y][x].d = ' '; |
| level[y][x].l = 0; |
| switch (levels[index].fileds[y][x]) |
| { |
| case 'b': |
| level[y][x].s = 'g'; |
| level[y][x].d = 'b'; |
| break; |
| case 'h': |
| player = Player(Point(x, y)); |
| level[y][x].s = 'g'; |
| break; |
| case 'x': |
| level[y][x].l = 6; |
| break; |
| } |
| } |
| gameStatus = GAME_NONE; |
| draw_window(); |
| } |
| void kos_Main() |
| { |
| rtlDebugOutString(" "); |
| rtlDebugOutString("kos_Main"); |
| char *cPtr; |
| cPtr = strrchr(kosExePath, '/'); |
| // ïðîâåðêà ;) |
| if (cPtr == NULL) |
| { |
| rtlDebugOutString("Invalid path to executable."); |
| return; |
| } |
| cPtr[1] = 0; |
| strcpy(cPtr + 1, "arh.pak"); |
| CKosFile *file = new CKosFile(kosExePath); |
| file->LoadTex((Byte*)img_box, 4, 24, 24); |
| file->LoadTex((Byte*)img_brick, 3, 24, 24); |
| file->LoadTex((Byte*)img_finish, 3, 24, 24); |
| file->LoadTex((Byte*)img_ground, 3, 24, 24); |
| file->LoadTex((Byte*)img_laser, 4, 24, 24); |
| file->LoadTex((Byte*)img_laser1, 4, 24, 24); |
| file->LoadTex((Byte*)img_laser2, 4, 24, 24); |
| file->LoadTex((Byte*)img_mirror, 4, 24, 24); |
| file->LoadTex((Byte*)img_mirror90, 4, 24, 24); |
| file->LoadTex((Byte*)img_mirror180, 4, 24, 24); |
| file->LoadTex((Byte*)img_mirror270, 4, 24, 24); |
| file->LoadTex((Byte*)img_mini_mirror, 4, 24, 24); |
| file->LoadTex((Byte*)img_mini_mirror90, 4, 24, 24); |
| file->LoadTex((Byte*)img_mini_mirror180, 4, 24, 24); |
| file->LoadTex((Byte*)img_mini_mirror270, 4, 24, 24); |
| file->LoadTex((Byte*)img_tank, 4, 24, 24); |
| file->LoadTex((Byte*)img_wall, 3, 24, 24); |
| file->LoadTex((Byte*)img_water, 3, 24, 24); |
| file->LoadTex((Byte*)img_waterbox, 3, 24, 24); |
| file->LoadTex((Byte*)img_brick1, 3, 24, 24); |
| file->LoadTex((Byte*)img_menu, 3, 384, 384); |
| file->LoadTex((Byte*)img_button, 3, 150, 50); |
| file->LoadTex((Byte*)img_explosion, 4, 24, 336); |
| delete file; |
| renderPlayer = new CKosRender(24, 24); |
| objPlayer = new CKosImage(renderPlayer, (RGBA*)img_tank, 24, 24); |
| renderLaser = new CKosRender(24, 24); |
| objLaser = new CKosImage(renderLaser, (RGBA*)img_laser, 24, 24); |
| objLaser->SetMode(DRAW_ALPHA_ADD); |
| objLaser1 = new CKosImage(renderLaser, (RGBA*)img_laser1, 24, 24); |
| objLaser1->SetMode(DRAW_ALPHA_ADD); |
| objLaser2 = new CKosImage(renderLaser, (RGBA*)img_laser2, 24, 24); |
| objLaser2->SetMode(DRAW_ALPHA_ADD); |
| renderMirror = new CKosRender(24, 24); |
| objMirror = new CKosImage(renderMirror, (RGBA*)img_mirror, 24, 24); |
| objMirror90 = new CKosImage(renderMirror, (RGBA*)img_mirror90, 24, 24); |
| objMirror180 = new CKosImage(renderMirror, (RGBA*)img_mirror180, 24, 24); |
| objMirror270 = new CKosImage(renderMirror, (RGBA*)img_mirror270, 24, 24); |
| objMiniMirror = new CKosImage(renderMirror, (RGBA*)img_mini_mirror, 24, 24); |
| objMiniMirror = new CKosImage(renderMirror, (RGBA*)img_mini_mirror90, 24, 24); |
| objMiniMirror = new CKosImage(renderMirror, (RGBA*)img_mini_mirror180, 24, 24); |
| objMiniMirror = new CKosImage(renderMirror, (RGBA*)img_mini_mirror270, 24, 24); |
| renderBox = new CKosRender(24, 24); |
| objBox = new CKosImage(renderBox, (RGBA*)img_box, 24, 24); |
| renderExplosion = new CKosRender(24, 24); |
| objExplosion = new CKosImage(renderExplosion, (RGBA*)img_explosion, 24, 24); |
| objExplosion->SetFrameSize(24, 24); |
| LevelsLoad(); |
| openLevel(0); |
| kos_SetMaskForEvents(0x27); |
| for (;;) |
| { |
| switch (kos_WaitForEvent()) |
| { |
| case 1: |
| draw_window(); |
| break; |
| case 2: |
| Byte keyCode; |
| kos_GetKey(keyCode); |
| key_press(keyCode); |
| break; |
| case 3: |
| kos_ExitApp(); |
| break; |
| case 6: |
| Dword buttons; |
| int mX, mY; |
| kos_GetMouseState(buttons, mX, mY); |
| if (buttons & 1) |
| MousePress(MOUSE_LEFT, Point(mX, mY)); |
| break; |
| } |
| } |
| } |
| /programs/games/LaserTank/trunk/LaserTank.sdf |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/LaserTank/trunk/LaserTank.sln |
|---|
| 0,0 → 1,20 |
| Microsoft Visual Studio Solution File, Format Version 11.00 |
| # Visual Studio 2010 |
| Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LaserTank", "LaserTank.vcxproj", "{A88BE65F-43CA-46F4-BC96-2B0ECC07C63B}" |
| ProjectSection(ProjectDependencies) = postProject |
| {911D4818-1AA1-4351-9C0A-38749130FAA6} = {911D4818-1AA1-4351-9C0A-38749130FAA6} |
| EndProjectSection |
| EndProject |
| Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "smalllibc", "smalllibc\smalllibc.vcxproj", "{911D4818-1AA1-4351-9C0A-38749130FAA6}" |
| EndProject |
| Global |
| GlobalSection(SolutionConfigurationPlatforms) = preSolution |
| Release|Win32 = Release|Win32 |
| EndGlobalSection |
| GlobalSection(ProjectConfigurationPlatforms) = postSolution |
| {A88BE65F-43CA-46F4-BC96-2B0ECC07C63B}.Release|Win32.ActiveCfg = Release|Win32 |
| {A88BE65F-43CA-46F4-BC96-2B0ECC07C63B}.Release|Win32.Build.0 = Release|Win32 |
| {911D4818-1AA1-4351-9C0A-38749130FAA6}.Release|Win32.ActiveCfg = Release|Win32 |
| {911D4818-1AA1-4351-9C0A-38749130FAA6}.Release|Win32.Build.0 = Release|Win32 |
| EndGlobalSection |
| EndGlobal |
| /programs/games/LaserTank/trunk/LaserTank.vcxproj |
|---|
| 0,0 → 1,78 |
| <?xml version="1.0" encoding="utf-8"?> |
| <Project DefaultTargets="Build" ToolsVersion="12.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>{A88BE65F-43CA-46F4-BC96-2B0ECC07C63B}</ProjectGuid> |
| <RootNamespace>LaserTank</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> |
| <PlatformToolset>v120</PlatformToolset> |
| </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> |
| <OutDir>h:\</OutDir> |
| </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) |
| "D:\Download\fasmw17122\FASM.EXE" $(ProjectDir)smalllibc\doexe2.asm $(TargetDir)$(TargetName)</Command> |
| </PostBuildEvent> |
| </ItemDefinitionGroup> |
| <ItemGroup> |
| <ClCompile Include="image.cpp" /> |
| <ClCompile Include="LaserTank.cpp" /> |
| <ClCompile Include="render.cpp" /> |
| </ItemGroup> |
| <ItemGroup> |
| <ProjectReference Include="smalllibc\smalllibc.vcxproj"> |
| <Project>{911D4818-1AA1-4351-9C0A-38749130FAA6}</Project> |
| </ProjectReference> |
| </ItemGroup> |
| <ItemGroup> |
| <ClInclude Include="image.h" /> |
| <ClInclude Include="render.h" /> |
| </ItemGroup> |
| <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> |
| <ImportGroup Label="ExtensionTargets"> |
| </ImportGroup> |
| </Project> |
| /programs/games/LaserTank/trunk/LaserTank.vcxproj.filters |
|---|
| 0,0 → 1,36 |
| <?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="LaserTank.cpp"> |
| <Filter>Файлы исходного кода</Filter> |
| </ClCompile> |
| <ClCompile Include="image.cpp"> |
| <Filter>Файлы исходного кода</Filter> |
| </ClCompile> |
| <ClCompile Include="render.cpp"> |
| <Filter>Файлы исходного кода</Filter> |
| </ClCompile> |
| </ItemGroup> |
| <ItemGroup> |
| <ClInclude Include="image.h"> |
| <Filter>Заголовочные файлы</Filter> |
| </ClInclude> |
| <ClInclude Include="render.h"> |
| <Filter>Заголовочные файлы</Filter> |
| </ClInclude> |
| </ItemGroup> |
| </Project> |
| /programs/games/LaserTank/trunk/Tupfile.lua |
|---|
| 0,0 → 1,13 |
| if tup.getconfig("NO_FASM") ~= "" or tup.getconfig("NO_MSVC") ~= "" then return end |
| HELPERDIR = (tup.getconfig("HELPERDIR") == "") and "../../.." or tup.getconfig("HELPERDIR") |
| tup.include(HELPERDIR .. "/use_msvc.lua") |
| if tup.getconfig("LANG") == "ru" |
| then CFLAGS = CFLAGS .. " /DLANG=RUS" |
| else CFLAGS = CFLAGS .. " /DLANG=ENG" |
| end |
| tup.append_table(OBJS, |
| tup.foreach_rule("memcmp.asm", "fasm %f %o", "%B.obj") |
| ) |
| table.insert(OBJS, "smalllibc/init.obj") -- ??? it doesn't work after fasm recompilation |
| compile_msvc{"smalllibc/func.cpp", "smalllibc/kosFile.cpp", "smalllibc/kosSyst.cpp", "smalllibc/math2.cpp", "smalllibc/mcsmemm.cpp", "smalllibc/purecall.cpp", "smalllibc/sprintf.cpp", "image.cpp", "render.cpp", "LaserTank.cpp" } |
| link_msvc("LaserTank") |
| /programs/games/LaserTank/trunk/customMode.h |
|---|
| 0,0 → 1,25 |
| class CCustomMode // áàçîâûé êëàññ |
| { |
| protected: // ñïåöèôèêàòîð äîñòóïà ê ýëåìåíòó value |
| public: |
| CCustomMode() |
| { |
| } |
| ~CCustomMode() |
| { |
| } |
| void Process() |
| { |
| } |
| void Draw() |
| { |
| } |
| }; |
| /programs/games/LaserTank/trunk/image.cpp |
|---|
| 0,0 → 1,130 |
| #include "kosSyst.h" |
| #include "render.h" |
| #include <func.h> |
| #include "image.h" |
| //#include "mymath.h" |
| CKosImage::CKosImage(CKosRender *render, RGBA *buffer, int width, int height) |
| { |
| this->isColor = false; |
| this->width = width; |
| this->height = height; |
| this->buffer = buffer; |
| this->render = render; |
| this->mode = DRAW_ALPHA; |
| this->frame = 0; |
| this->frameWidth = 0; |
| this->frameHeight = 0; |
| } |
| CKosImage::~CKosImage(void) |
| { |
| } |
| void CKosImage::SetMode(int mode) |
| { |
| this->mode = mode; |
| } |
| void CKosImage::SetFrameSize(int width, int height) |
| { |
| this->frameWidth = width; |
| this->frameHeight = height; |
| } |
| void CKosImage::Draw(Point position, float angle, RGB color) |
| { |
| this->isColor = true; |
| this->color = color; |
| this->Draw(position, angle); |
| this->isColor = false; |
| } |
| int CKosImage::getPixel(int x, int y) |
| { |
| return y * this->width + x; |
| } |
| void CKosImage::Draw(Point position, float angle, int frame) |
| { |
| this->frame = frame; |
| Draw(position, angle); |
| } |
| void CKosImage::Draw(Point position, float angle) |
| { |
| float alpha; |
| Point p, p1; |
| RGB pixel, newPixel; |
| RGBA addPixel; |
| int PixelID; |
| Point fix; |
| if (angle == 270) |
| fix = Point(0, -1); |
| else |
| if (angle == 180) |
| fix = Point(-1, -1); |
| else |
| if (angle == 90) |
| fix = Point(-1, 0); |
| else |
| fix = Point(0, 0); |
| Point center = Point(this->width / 2, this->height / 2); |
| double a = -angle * (3.14 / 180); |
| double SinRad = sin(a); |
| double CosRad = cos(a); |
| for (int y = 0; y < 24; ++y) |
| for (int x = 0; x < 24; ++x) |
| { |
| p1 = Point(x, y) - center; |
| p.X = roundInt(p1.X * CosRad - p1.Y * SinRad) + center.X; |
| p.Y = roundInt(p1.X * SinRad + p1.Y * CosRad) + center.Y; |
| if (p.X >= 0 && p.X < this->width && p.Y >= 0 && p.Y < this->height) |
| { |
| p.Y += this->frame * this->frameHeight; |
| addPixel = this->buffer[this->getPixel(p.X, p.Y)]; |
| PixelID = this->render->getPixel(x + fix.X, y + fix.Y); |
| pixel = this->render->buffer[PixelID]; |
| if (addPixel.a > 0) |
| { |
| if (this->isColor) |
| { |
| addPixel.r = this->color.r; |
| addPixel.g = this->color.g; |
| addPixel.b = this->color.b; |
| } |
| alpha = (float)addPixel.a / 255.0f; |
| if (this->mode = DRAW_ALPHA) |
| { |
| newPixel.r = di((double)(pixel.r * (1 - alpha) + addPixel.r * alpha)); |
| newPixel.g = di((double)(pixel.g * (1 - alpha) + addPixel.g * alpha)); |
| newPixel.b = di((double)(pixel.b * (1 - alpha) + addPixel.b * alpha)); |
| } |
| else |
| if (this->mode = DRAW_ALPHA_ADD) |
| { |
| newPixel.r = di(min(255, (double)(pixel.r * (1 - alpha) + addPixel.r * alpha))); |
| newPixel.g = di(min(255, (double)(pixel.g * (1 - alpha) + addPixel.g * alpha))); |
| newPixel.b = di(min(255, (double)(pixel.b * (1 - alpha) + addPixel.b * alpha))); |
| } |
| else |
| { |
| newPixel.r = addPixel.r; |
| newPixel.g = addPixel.g; |
| newPixel.b = addPixel.b; |
| } |
| this->render->buffer[PixelID] = newPixel; |
| } |
| } |
| } |
| } |
| /programs/games/LaserTank/trunk/image.h |
|---|
| 0,0 → 1,31 |
| #include <kosSyst.h> |
| #define DRAW_NONE 0 |
| #define DRAW_ALPHA 1 |
| #define DRAW_ALPHA_ADD 2 |
| class CKosImage |
| { |
| private: |
| bool isColor; |
| RGB color; |
| int getPixel(int x, int y); |
| Byte mode; |
| int frame; |
| int frameWidth; |
| int frameHeight; |
| public: |
| CKosImage(CKosRender *render, RGBA *buffer, int width, int height); |
| ~CKosImage(void); |
| void Draw(Point position, float angle, RGB color); |
| void Draw(Point position, float angle); |
| void Draw(Point position, float angle, int frame); |
| void SetMode(int mode); |
| void SetFrameSize(int width, int height); |
| protected: |
| CKosRender *render; |
| RGBA *buffer; |
| int width; |
| int height; |
| }; |
| /programs/games/LaserTank/trunk/levels.lvl |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/LaserTank/trunk/memcmp.asm |
|---|
| 0,0 → 1,15 |
| format MS COFF |
| section '.text' code readable executable |
| public _memcmp |
| _memcmp: |
| push esi edi |
| mov esi, [esp+12] |
| mov edi, [esp+16] |
| mov ecx, [esp+20] |
| repz cmpsb |
| pop edi esi |
| setb ah |
| seta al |
| sub al, ah |
| movsx eax, al |
| ret |
| /programs/games/LaserTank/trunk/render.cpp |
|---|
| 0,0 → 1,34 |
| #include "kosSyst.h" |
| #include "render.h" |
| CKosRender::CKosRender(int width, int height) |
| { |
| this->width = width; |
| this->height = height; |
| this->buffer = new RGB[width * height]; |
| for (int i = 0; i < width * height; i++) |
| this->buffer[i] = 0x000000; |
| } |
| CKosRender::~CKosRender(void) |
| { |
| //delete this->buffer; |
| } |
| void CKosRender::Draw(Point position) |
| { |
| kos_PutImage((RGB*)this->buffer, this->width, this->height, position.X, position.Y); |
| } |
| void CKosRender::RenderImg(RGB *img, Point position, int width, int height) |
| { |
| for (int i = 0; i < width * height; i++) |
| this->buffer[i] = img[i]; |
| // if ( ) |
| // this->buffer[getPixel(x, y)] |
| } |
| int CKosRender::getPixel(int x, int y) |
| { |
| return y * this->width + x; |
| } |
| /programs/games/LaserTank/trunk/render.h |
|---|
| 0,0 → 1,15 |
| class CKosRender |
| { |
| public: |
| RGB *buffer; |
| int width; |
| int height; |
| CKosRender(int width, int height); |
| ~CKosRender(void); |
| void Draw(Point position); |
| void RenderImg(RGB *img, Point position, int width, int height); |
| int getPixel(int x, int y); |
| // void DrawImage(CKosImage *img, int x, int y, int angle); |
| }; |
| /programs/games/LaserTank/trunk/smalllibc/doexe2.asm |
|---|
| 0,0 → 1,68 |
| 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 |
| /programs/games/LaserTank/trunk/smalllibc/func.cpp |
|---|
| 0,0 → 1,550 |
| #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; |
| } |
| double sqrtd(double x) |
| { |
| __asm fld x |
| __asm fsqrt |
| } |
| double arccos(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 |
| } |
| double atan(double Rad) |
| { |
| _asm{ |
| fld dword ptr[Rad] |
| fld1 |
| fpatan |
| fstp dword ptr[Rad] |
| } |
| return Rad; |
| } |
| double atan2(double x, double y) |
| { |
| return abs(atan(y / x) /* (180 / M_PI)*/); |
| } |
| int roundInt(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; |
| } |
| /programs/games/LaserTank/trunk/smalllibc/func.h |
|---|
| 0,0 → 1,135 |
| #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); |
| double atan(double x); |
| double arccos(double x); |
| double sqrtd(double x); |
| double atan2(double x, double y); |
| int roundInt(double x); |
| /programs/games/LaserTank/trunk/smalllibc/init.asm |
|---|
| 0,0 → 1,31 |
| 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: |
| /programs/games/LaserTank/trunk/smalllibc/init.obj |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/LaserTank/trunk/smalllibc/kosFile.cpp |
|---|
| 0,0 → 1,137 |
| #include "kosSyst.h" |
| #include "kosFile.h" |
| //#include "string.h" |
| CKosFile::CKosFile(char *fileName) |
| { |
| // |
| rtlDebugOutString(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; |
| } |
| void CKosFile::LoadTex(Byte *targetPtr, Byte Size, int width, int height) |
| { |
| this->Read(targetPtr, width * height * Size); |
| } |
| /programs/games/LaserTank/trunk/smalllibc/kosFile.h |
|---|
| 0,0 → 1,27 |
| #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); |
| void LoadTex(Byte *targetPtr, Byte Size, int width, int height); |
| protected: |
| int filePointer; |
| int bufferPointer; |
| bool validBuffer; |
| kosFileInfo fileInfo; |
| void ValidateBuffer(void); |
| void UpdateBuffer(void); |
| }; |
| /programs/games/LaserTank/trunk/smalllibc/kosSyst.cpp |
|---|
| 0,0 → 1,708 |
| #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 |
| float Point::Lingrh() |
| { |
| return sqrtd(this->X * this->X + this->Y * this->Y); |
| } |
| float Point::Angle() |
| { |
| return atan2(this->X, this->Y); |
| } |
| // |
| 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{ |
| mov eax, 70 |
| mov ebx, fileInfo |
| int 0x40 |
| // 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(); |
| } |
| /programs/games/LaserTank/trunk/smalllibc/kosSyst.h |
|---|
| 0,0 → 1,300 |
| #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 Point |
| { |
| int X; |
| int Y; |
| Point() {}; |
| Point(int x, int y) |
| { |
| this->X = x; |
| this->Y = y; |
| }; |
| bool operator != (Point &a){ return this->X != a.X || this->Y != a.Y; }; |
| bool operator == (Point &a){ return this->X == a.X && this->Y == a.Y; }; |
| Point operator + (Point &a){ return Point(this->X + a.X, this->Y + a.Y); } |
| Point operator + (int a){ return Point(this->X + a, this->Y + a); } |
| Point operator - (Point &a){ return Point(this->X - a.X, this->Y - a.Y); } |
| Point operator - (int a){ return Point(this->X - a, this->Y - a); } |
| Point operator * (Point &a){ return Point(this->X * a.X, this->Y * a.Y); } |
| Point operator * (int a){ return Point(this->X * a, this->Y * a); } |
| Point operator / (Point &a){ return Point(this->X / a.X, this->Y / a.Y); } |
| Point operator / (int a){ return Point(this->X / a, this->Y / a); } |
| float Lingrh(); |
| float Angle(); |
| }; |
| struct Rect |
| { |
| int X; |
| int Y; |
| int Width; |
| int Height; |
| Rect() {} |
| Rect(int X, int Y, int Width, int Height) |
| { |
| this->X = X; |
| this->Y = Y; |
| this->Width = Width; |
| this->Height = Height; |
| } |
| }; |
| struct RGBA |
| { |
| Byte b; |
| Byte g; |
| Byte r; |
| Byte a; |
| RGBA() {}; |
| RGBA(Dword value) |
| { |
| a = (Byte)(value >> 24); |
| r = (Byte)(value >> 16); |
| g = (Byte)(value >> 8); |
| b = (Byte)value; |
| }; |
| // |
| bool operator != (RGBA &another) |
| { |
| return this->b != another.b || this->g != another.g || this->r != another.r || this->a != another.a; |
| }; |
| // |
| bool operator == (RGBA &another) |
| { |
| return this->b == another.b && this->g == another.g && this->r == another.r && this->a == another.a; |
| }; |
| }; |
| 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; |
| }; |
| }; |
| struct Player |
| { |
| Point vector; |
| Point position; |
| float angle; |
| Player() {} |
| Player(Point position) |
| { |
| this->vector = Point(0, -1); |
| this->position = position; |
| this->angle = 270; |
| }; |
| }; |
| #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(); |
| /programs/games/LaserTank/trunk/smalllibc/math2.cpp |
|---|
| 0,0 → 1,87 |
| #include <math.h> |
| #include "kosSyst.h" |
| extern "C" int _fltused = 0; |
| #define M_PI 3.14159265358979323846 |
| 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 |
| } |
| } |
| /programs/games/LaserTank/trunk/smalllibc/mcsmemm.cpp |
|---|
| 0,0 → 1,373 |
| // 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; |
| } |
| */ |
| /programs/games/LaserTank/trunk/smalllibc/mcsmemm.h |
|---|
| 0,0 → 1,28 |
| // |
| 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 ); |
| /programs/games/LaserTank/trunk/smalllibc/mymath.h |
|---|
| 0,0 → 1,95 |
| /* 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); |
| } |
| /programs/games/LaserTank/trunk/smalllibc/purecall.cpp |
|---|
| 0,0 → 1,11 |
| #include "kosSyst.h" |
| static char pureCallMessage[] = "PURE function call!"; |
| // âûçîâ àáñòðàêòíîãî ìåòîäà |
| int __cdecl _purecall() |
| { |
| rtlDebugOutString( pureCallMessage ); |
| kos_ExitApp(); |
| return 0; |
| } |
| /programs/games/LaserTank/trunk/smalllibc/smalllibc.vcxproj |
|---|
| 0,0 → 1,73 |
| <?xml version="1.0" encoding="utf-8"?> |
| <Project DefaultTargets="Build" ToolsVersion="12.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>{911D4818-1AA1-4351-9C0A-38749130FAA6}</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> |
| <PlatformToolset>v120</PlatformToolset> |
| </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> |
| /programs/games/LaserTank/trunk/smalllibc/smalllibc.vcxproj.filters |
|---|
| 0,0 → 1,60 |
| <?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> |
| /programs/games/LaserTank/trunk/smalllibc/sprintf.cpp |
|---|
| 0,0 → 1,228 |
| #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; |
| } |