Click here for docs.
Or click here to get back to github from the docs.
This is a remake of my LibTi84 project and aims to provide a means for the construction of games for the ti-84 (NON CE). This is more or less a culmination of all my knowledge in this niche field. I am not an expert. And this is a personal tool I use in my quest for a real-time 3d game for the ti-84. Everything should be capable of being built as an app or as a program (As long as you don't use any non-constant global variables).
I do not plan to rely on any shells, although Noshell is recommended for asm programs. This is made for linux, although you can use WSL if you must use windows.
First, make sure you have the right project, this is for the ti-84 monochrome calculators, if your calculator has color you have come to the wrong place. Next, I recommend you use an emulator for development so you don't brick your real device, I personally never run anything other than the end product on my physical calculator. You might want to use jsTIfied, an Online TI-83+/TI-84+ Graphing Calculator Emulator hosted on cemetech. But if you use an emulator you will need a rom (Read Only Memory dump of a calculator), the legal option is to dump your calculator's rom using rom 8x, although you can also download a rom from archive.org. Next, you will need to follow the installation steps. If you have the helloworld successfully building and running in the emulator you are about done. At this point, if you don't know what to do now, I recommend you learn how to program with the calculator from ti-84 in 28 days guide, I know you came here for C, but it provided essential info. Along with SDCC - Interfacing with Z80 assembler code, whitch provides essential info on how to use inline asm and differences with sdcc's z80 asm and what the guide uses. Also look in the src/ and look as what functions are avalible to use.
Ok, ok, I know that was a lot to digest, but if you did all that, you are now ready to make all sorts of cool shit. If you want to make fun 2d games you can do it all in c(sort of), if you want to make some 3d games, you might not have such luck. That is what this project's goal is, to make a real-time 3d game, but that is quite hard with this calculator being an 8-bit device with half-baked 16-bit compatibility. But as of now, a world of possibilities is opened.
- First im going to assume you are using linux, or at least set up WSL. Although if you don't want to install anything you can try out github codespaces and skip the clone step, but everytime you build you need to download file.
- Clone this repo with:
git clone https://github.com/HeronErin/TiConstructor.git - Install SDCC version 4.1
- Download SDCC version 4.1 from This Url
- Extract and install with
tar -xvjf sdcc-4.1.0-* && sudo cp sdcc/bin/* /usr/bin/ && sudo cp -r sdcc/share/* /usr/share/ - Remove the sdcc folder as it is nolonger needed
rm -rf sdcc
- If you are using Ubuntu you need to use the rabbitsign ubuntu versing
rm other_files/rabbitsign && mv other_files/rabbitsign_ubuntu_build other_files/rabbitsign && chmod +x other_files/rabbitsign - Test it out
build_prog.sh examples/helloworld/ helloWorldor
build_app.sh examples/helloworld/ helloWorldNow that you have a working build system, install tilp (or TI Connect for windows) and send the file to your calc.
This is not something that was simple to figure out, there is no unified guide to the ti84/ti83+. But here is my explanation of what this toolkit does. SDCC compiles c code to z80 assembly and assembles it into a binary file. Then if you are making a program binpac8x.py will pack it into a program file (.8xp). If you are making an app a buildid is generated for you, my script generates a custom header for you, and rabbitsign will sign it with the freeware key and converts it to an app file (.8xk). But thanks to the work of me and the giants whose shoulders I stand on, that is all abstracted away from you with a single line build command.
For you, the developer, I gave you a few files in the lib/ forlder, these are some useful tools for what ever you are making. Since you are often trying to keep build sizes down, many functions require you to enable them with #define USE_FUNCTION_NAME after you #include the source file. I recommend you look at the source code of the library itself for the exact #includes you need to use. And now there exists some documentation for this toolkit over here.
Ps. Don't remove the .buildid files, you need to keep the same .buildid everytime you update an app on your calculator
- The documentation for this library
- Best guide to z80 asm
- Offical ti-84+ sdk archive.org page.
- Some useful bcalls
- Useful table for t-state timing
- wikiti for almost all bcalls and ram addresses
- Hub of ti dev community
- Old United-TI for useful routines not on cemetech
- Omnimaga has a shit ton of usefull stuff a with I knew about sooner
- T-state counter for those making high speed games and a tampermonkey script that makes it better by adding up the t-states
- Greyscale I wish I might one day be smart enough to implement
- When you build an app, a .buildid file is generated with a unique(ish) id for your app. This is what allows you to update it on the calculator because can't replace an app on your calculator with an app with the same name but a different build id, and the calculator refuses to allow 2 apps to exist with the same build id, so don't delete your .buildid or you will be forced to get a new name >:{
- Since apps require you to bcall JForceCmdNoChar before you exit, I came up with an interesting trick to do this for you, since I didn't want a mandatory bcall. If you push a value to the stack without popping it, the ret keyword will jump to that memory address, this is how functions work, so before your app runs, I simply push the address of my code that runs the required bcall, making this run after your main function returns.
I did take some code from others, I just can't do it all myself.
- Thanks Xeda112358 for the routine for converting registers to op values
- Thanks to whoever wrote the TI-83 Plus calculator in 28 days guide for the fast clear buffer routine and the GetPixel routine
- Thanks James Montelongo Jr, who wrote the fast dline routine
- Thanks to the geeksforgeeks authors for the circle function
- Thanks to Sorunome for the flash app interupt loader