Trying to get support for more than one graph, but its clearly not working.

• Fixed the jitter in the linux version of the grapher.
• Added more optimization.

• Cleaned up the makefile.
• Made changes to the project structure.
• Added the option to turn on/off graph smoothing using -s when running the app as shown in the picture.

Done

• I finally finished linux support.
• Made my own itoa function, so now the grapher should work with older windows versions and linux.
• Made more optimizations.

To do

• Add support for multiple functions at once.
• Add the option to turn on/off the graph smoothing.
• Optimize the grapher even more, because it’s a little slow right now.

• I optimized the app a little.
• Finally finished the graph smoothing, although it is a little slow.
  So I might add the option to turn it on and off when running the app.
• Still have to add support for more than one func and maybe add usefull stuff like intersect and whatnot.

• Finally Finished linux support, although, the grapher uses windows only functions, so only the pong game can be played on linux.

To Do

• Add full linux support

• Fixed bugs in the evaluater, now it has proper operator presidence.

I don’t feel like adding support for negative values or decimals, so,

• if you want to use negative numbers, do:

    0 - n ... # for example

• If you wanna use decimals, do:

    1/2 ... # for example

Math

• Fixing the evaluater, not done yet.

Grapher

• Still haven’t smoothed it, i will try for another day, if I can’t get it to work, I might have to use the help of AI.

To Do

• Add support for negative numbers.
• Add support for decimal numbers.
• Add support for parentheses.

Done:

• Finally finished the docs, so the project is easier to understand.

To Do:

• Finish adding linux support.
• Fix the math parser.
• Change and Improve the visuals for the func plotter.
• Be done.

Merged The two wakatime projects because I only now figured out how to do it.

• I fixed more bugs with the renderering api.
• I made docs for both the input and renderering apis but my pc crashed so I have to restart all over.

What I did

• I was getting tired of not being able to make the graphing calculator work like I want, so instead I:
  • Made the linux renderer but haven’t tested it yet.
  • Worked on input on linux.
• I also fixed a bug in the pong game where the menu text was off centered when you change the size of the window.

• Updated the ASCII chars used to draw the axies.
• Struggling to get the code that fills empty y spaces to work, still isn’t working as shown in the picture.

• I made my own vector2 data type because I was using COORD from the win32 API, but that’ll make it require different code for different operating systems, So I made my own.
• I also update my grapher and pong clone to use the new Vec2 data type.

Grapher:

• I added the x and y axis so you can better visualize the graph.
• I fixed bugs related to the graph’s position.
• I added the ability to enter as many X variables as you want.

Problems:

• I did have a problem where I wanted to add colors but my double buffering method doesn’t seem to be compatible with coloring. So I will do some more research on that, tho whether I can add color or not is up to the win32 API.

Extra:

• And as the pictures show, the graph is pretty similar to the one made with ‘Desmos’.

General:

• I fixed some bugs:
  • Graphics flickering.
  • Input not registering.
• And I also added a camera so you can look around.
• And I also added Error checking for input.

Game-engine:

• I added a new function for if you only want to use a single buffer.
• I changed some misleading variable names and function names.

Done:

• Made a Semi-Working evaulater.
• You can now graph funcs but they’re looking at the wrong direction.

To Do:

• Improve the parser to handle more than one x value.
• Add operator presidence.
• Add support for negative numbers.

Everything already done

• Windows Input system and renderer
• Basic CLI game-engine
• Pong game

Future plans

• I’m planning on adding the math evaluater.
• Adding a menu bar with usefull tools.
• Implementing the graphing calculator.

pong

• Implement ball physics, collisions and UI tweaks.
• I finished the pong game.

game

• Added bounds checking.
• Stopped using hard coded ball position.
• Added a start screen.

general

• Added docs template.
• Improved Makefile.

• Improved the rendering API.
• Fixed bug where the console wouldn’t fully get cleared.
• Added a games directory and made it a basic pong template.

• Added option to compile game and grapher separately in the Makefile.

Add a new math subsystem and integrate it into the project build and main flow.

• Add src/core/math/math.c and math.h: implement square(), cube(), a tokenizing parse() function and a stub evaluate() (currently returns 0). parse() allocates token strings and returns count.
• Update makefile to include the math source for win and unix targets.
• Modify renderer: move buffer initialization into swap_buffers() (removed init_buffers implementation) so cursor info is set when swapping.

These changes wire a new math parser into the app and refactor the renderer behavior; evaluate() is still incomplete and will need implementation and memory management review for parse() allocations.

• I tried making the character move with WASD which made me realize my old code didn’t work as expected so I switched input detection on windows from using <conio.h> to <windows.h>.
• And as you see the new input system works very well.

• Also planning to add docs for anyone who wants to use the game-engine by itself for himself…

Rename and simplify renderer functions, add FPS control, and add keyboard constants.
init_win_cli() -> init_renderer(), clear_con() -> clear_console(), swap_buffers(float) -> swap_buffers() and a new set_fps(float) were introduced.
init_renderer() now sets a default fps of 60.
main.c updated to use the new renderer API (init_renderer, clear_console, swap_buffers) and removed the old cursor positioning usage.
Also added KEY_A..KEY_Z defines to src/input/win_input.h for letter key codes.

Will add a camera system and a status bar with usefull commands in the future.

Introduce key constants and input helper functions (esc_pressed, key_pressed, arrow_key_pressed) in win_input.* to centralize keyboard handling. Add draw_char and draw_chars wrapper functions in renderer to encapsulate WriteConsoleOutputCharacterA usage and update main to use draw_char. Minor whitespace/comment cleanup in main.

Refactor codebase to separate Windows and Unix platform layers and improve build targets.

• Makefile: add CC/CFLAGS, variables, and explicit win and unix targets; run now uses the built binary. Unix build is stubbed with a helpful message (unix support not implemented yet).
• Platform refactor: rename/move Windows-specific modules: src/input.c -> src/input/win_input.c and src/win_cli.c -> src/renderer/win_renderer.c; corresponding headers moved/renamed under input/ and renderer/.
• Additions: add placeholder Unix sources/headers (src/input/unix_input.* and src/renderer/unix_renderer.*) to prepare for Unix support.
• Remove cli_os_layer.h and replace with conditional includes in main.c (#ifdef _WIN32 / #else) to include the correct platform headers.
• API change: swap_buffers parameter type changed from int to float; implementation adjusts Sleep timing (Sleep(fps / 3.75)) and call site updated from swap_buffers(16) to swap_buffers(60.0).

These changes prepare the project for cross-platform support and cleaner separation of platform-specific code while improving the build workflow for Windows. Unix implementation remains to be completed.

Made basic text rendering with double buffering to reduce flicker.

messed around with the main idea but still coudlnt get it to work,
and changed the color theme.

bug fixes, added support for 2 players on the same device, added a main menu, and added a simple score system.

added an AI paddle that just follows the balls y position and added touch screen controls, also messed around with multiplayer but didn’t add it.

i made the player and the ball, and made the ball bounce off the player and walls.