This is a simple program I made today that can bounce hundreds of balls around the screen and has the ability to add, remove, and clear and change the graphics of. It is a pretty entertaining program, and the source code is something you should really peruse if you wish to take a look at how to use interrupts and the keypad in your C programs. Enjoy

Download: BounceCE



[on]     - Quits the program
[clear]  - Clears the screen
[del]    - Delete latest ball
[+]      - Shows number of balls
[-]      - Switches between filled and outline
[enter]  - Toggles background color

Made a nice little chess game in C for the CE calculator. Enjoy It includes autosaving and different modes, much like CheckersCE

Download: Chess CE

Oiram is a Mario-like platformer for the CE:

Oiram Download: Download
Oiram Level Editor: Download

I got bored today so I optimized and cleaned up the code some; and added in a so called "Hacked Version", where you can play on a different map rather than the original one. This should be a nice change to the hum drum of daily life. Simply press [5] on the home menu with the "insert coin" message to enable the new map. It will reset once you exit the game. Amaze all your friends with your awesome hacking skills

Download: https://www.cemetech.net/programs/index.php?mode=file&path=/84pce/asm/games/PacManCE.zip

GIF is slow. I blame someone.

Because of the advent of C, the CE is open to a lot more possibilities. I went ahead and grabbed a nice looking checkers engine and coded the interface and GUI around it, including user movement and such. Now you can play checkers against a pretty difficult AI Or even make the calculator play against itself, which is enjoyable to watch I guess. Anywho, here's some screenshots and hopefully the download will be up shortly. It also auto-saves all the positioning and board information, so reloading your games is a breeze. Hopefully the source is inspirational to someone All told, this took about a day to make, so in all seriousness, I <3 C.




Download: CheckersCE

ConvPNG Link: Download

ConvPNG has just gotten a massive update, which will be extremely useful for C and ASM programmers alike. It can now take groups of images, determine the best palette for each group, and then convert each image using the palette. It also allows reserving a certain color for transparency, so you can have transparent sprites. Rather than being just a command-line tool, it now is more of a hybrid and uses 'convpng.ini' in the images directory in order to easily be able to group and convert images. A sample one with 2 palettes (or groups) may look like this:

#GroupC            : gfx_group_1
#Compression       : none                 (Compression type: none, rle, lz77)
#TranspColor       : 255,255,255,255      (Transparent color: r,g,b,a - a will most always be 255)
#Sprites           :                      (List of sprites for this group to convert)
image0
image1
image2

#GroupC            : gfx_group_2
#Compression       : lz77                 (Compression type: none, rle, lz77)
#Sprites           :                      (List of sprites for this group to convert)
image3
image4
image5
image6

It also supports rle and lz77 compression of images, in order to help reduce size. Huffman was considered, but doesn't really perform well for palette-driven images. Color conversion is also a lot closer thanks to help from Runer. Overall, I hope that you all will find this quite useful

Let me know if you need any help working with it; or if you have and suggestions/comments. Enjoy!

For the technically inclined, it uses a combination of mediancut and K-means in order to choose the best palette for the groups of images.

Hello all! I'm happy to announce that version 1.0 of the C development SDK for the TI84+CE and TI83PCE is available on GitHub now. Rather than going through this crazy process, you can now simply download the zip file, copy the folder to somewhere on your computer, set up your environment variables specific to your OS, and then use make in order to build your programs locally. Of course, it uses the ZDS compiler which is only natively supported on Windows, but works perfectly under Wine. If you wish to avoid even more hassle and you have access to the onlines, you can also use TI Planet's C Project Builder, available here: https://tiplanet.org/pb/ (You will need an account if you don't have one)

Now, ignoring all the craziness that happened with licenses, some standard CE C libraries have also been released. Currently there are 2; one for graphics and one for interfacing with the keypad. Included in each you will also find example programs in C using these libraries, and ASM source code licensed under the BSD 2 Clause. These libraries outperform their direct C equivalent as they are written in assembly and can behave however they want. Since they are still in version 1.0, there's a long way to go. But since things are easy to add to now, hopefully I can get some help Anywho, here are the links so you can build your own programs, along with a screenshot using the C graphics library just for fun.

C Development SDK: https://github.com/CE-Programming/toolchain/releases
C Standard Libraries: https://github.com/CE-Programming/libraries/releases
LibLoad, for use with C libraries: https://github.com/CE-Programming/libload/releases

Enjoy everyone, and please post any pull requests/bug reports and comments you may have! This has been a long ride



Note:To install libraries so you can use them in development, simply read the readme provided on GitHub or in the zip. It's really easy.

Hello everyone. Early last month I started work on a CE calculator emulator, and it has now progressed to a nice development stage. Jacobly, Adriweb, and Lionel were very helpful along the way, and fixed a lot of the bugs I always seemed to make, and of course did an amazing job at implementing a lot of the more wild things. But now it is in working stages; support for ROM dumping from a real calculator is supported, it can boot and operate exactly like a normal TI-OS, except for file transfers, which requires emulating USB, which will take some time. There is no release yet; only a source release (which you can build yourself and play with if you so desire), and if you have sufficient knowledge in anything you feel could help out, feel free to send a pull request my way or ask nicely and I can add you as a collaborator. Rather than talk some more about it; Adriweb came up with a nice article that will explain a lot, I hope. Still a lot to do, but yay.

So, give it a test drive, and report any bugs/features/comments that you have or would like implemented, and they will be added to the todo list. Enjoy.

It has its own ROM dumping method, much like the rom8x of days past, but now a nice GUI to tell you everything. And a progress bar. Those are cool. Of course, Lionel and jacobly added ROM dumping support to TILP here.

Source code on GitHub : https://github.com/MateoConLechuga/CEmu

Cross news post:

CEmu: What is it?
To sum up: a portable and open-source TI-84 Plus CE and TI-83 Premium CE emulator.

The 84+CE and 83PCE (TI-eZ80 series) hit the market over half a year ago. However, there was no third-party emulator, and the official emulator in TI-SmartView CE does not provide the features most community programmers have come to expect from well-behaved emulators: an accurate emulation core, a debugger with a way to inspect and modify registers and memory, a disassembler, etc. Teachers, who are SmartView's main target audience, hardly need such features.
The lack of a proper emulator is a significant roadblock to making TI-eZ80 native code programming popular in the community, which is a shame because the platform is a great improvement over the 84+CSE: faster CPU, more RAM, etc. Therefore, for the community's sake, such a situation shouldn't last for long - hence, the making of an emulator

CEmu is open source (and even free software, under the GPLv3), like nearly all community-made emulators, and made in C/C++. A native code emulator makes perfect sense for both efficiency and versatility; in the longer term, retargeting the code at browsers (JavaScript, WebAssembly) is possible nowadays, thanks to Emscripten.

The team behind CEmu
Matt "MateoConLechuga" Waltz started the project and remains the main contributor.
More recently, Jacob "jacobly" Young was invited to join the fun, and he has so far worked quite a bit on improving the CPU and ASIC core (as well as integration thereof with the UI), mainly.
The CEmu code base leverages both Firebird (TI-Nspire emulator) and z80e (TI-Z80 emulator for KnightOS, and to which jacobly is a contributor) open-source projects.
There are also other contributions, from non-TI-(e)Z80 experts: Adrien "Adriweb" Bertrand, Lionel Debroux, Fabian "Vogtinator" Vogt.
And in the future... well, potentially anyone with sufficient knowledge, that's precisely part of the power of open source

If you want to chat, we're on IRC (EFNet), on channels such as #ez80-dev and #cemu-dev

Features

• Portable emulation core written in C
  
• Decent emulation accuracy yielding the ability to boot all of TI's CE OS's, browse around, execute self test successfully, and run programs.
  
• Portable GUI written in C++ using Qt (making it run on Windows, Mac OS X, Linux, Android, and iOS!)
  
• Docks/Tabs-based graphical UI (which you are able to customize)
  
• Integrated setup wizard with ROM dumper for your calculator (there's another one in TILP beta)
  
• Simple debugger (read CPU registers, flags, ASIC state) and port monitor/writer
  
• Animated (GIF) and still (PNG) screenshots
  

What it looks like
Here is what a recent build on Mac OS X looks like:

Of course, using the docking system, all windows are completely resizeable, movable, and translatable.

Short-term todo list

• Continue implementing the ASIC emulation core: remaining devices/ports, etc.
  
• Implement file transfers (implementing USB is not an easy task, so that will probably take a while)
  
• Make the debugger more useful: disassembly view, stepping, breakpoints...
  
• Finish 83PCE support (e.g. keypad and skin - emulating the 83PCE already works)
  
• Test the emulator and hunt bugs, even more!
  

In the future...

• Provide more translations (for now, it's available in English and French). If you want to help, tell us, or send patches / pull requests!
  
• Make a web-based version of CEmu, like there's a web-based version of z80e for trying out KnightOS. Compiling the CEmu core to JavaScript (and later WebAssembly), using Emscripten, is already known to work: Adriweb has been able to get an Emscriptened CEmu core to boot a ROM and get to the home screen (confirmed by dumping the LCD buffer)
  
• Think about CEmu's core's integration on third-party projects, like TI-Planet's Project Builder - for instance, in C projects, in order to directly test the program, and eventually (if someone has enough time...) have live source-level debugging!
  
• Look at this gdb-z80 project (code from 2011...); try to see if it can be updated for eZ80, and used with a CEmu GDB stub. Mainlining such code is highly preferable.
  
• ...
  

Conclusion
To sum up: CEmu is the community's open-source, native, portable, TI-84 Plus CE / TI-83 Premium CE emulator, that has been developed over the past few weeks, and of course, still is currently under development.
We all hope you'll enjoy it

Download : Soon ! There is no binaries to download yet, you'll have to be a little more patient
Source code on GitHub : https://github.com/MateoConLechuga/CEmu

In the meantime, you can simply build one yourself from the source code (instructions here)

Merry (belated) Christmas!

So I am working on a Portal game for the TI84+CSE edition, and I thought that I would cross post from Cemetech to provide some eye candy. Well, here you go!

Quote from: MateoConLechugaPortal, now under development for the TI84+CSE series calculator! All project updates will be posted here.

Current Level Progress: 3/40 Complete
Level Editor Progress: 11%

Okay, here are some differences that I currently have:
::Energy balls can toggle switches -- Should make more puzzles available
::Doors can be controlled by multiple buttons -- See above ^^

Controls:
[LEFT/RIGHT] - Select Level
[MODE] - Quits in-game
[ALPHA] - Speeds up text
[CLEAR] - Quits in a text display or main menu

[Download Link]

Current Screenshots:



Older, but still the same thing and relevant, screenshot:


Finished: (Or, more accurately, "Hey it works right!")
::PHYSICS!!! (With friction too. )
::Movement within Portals
::Portal Shooting
::Portal Bumping
::Portal On Portal Bumping
::Portal Clipping
::Portal Movement
::Level Loader
::Collision Detection
::Button Collision
::Doors
::Energy Balls
::Energy Ball Switches
::Glass Walls
::Portal Eraser Fields
::Spikes
::Splash Screen
::Lifting Crates
::Crate Bumping
::Transitions
::Crate Physics
::Custom Color Background
::Main Level Pack is an AppVar
::Fail Animation
::Level Decompression
::Throwing Crates
::Transitions
::Text/Story between levels
::Better Splash Screen
::New Custom Text

Currently In Progress:
::Custom Maps/Level Editor
::Level Editor Compressor
::Main Level Pack
::Random Bug Fixes
::Testing - Oh boy, that will be fun...

TODO:
Wow, the TODO list is empty because everything is being worked on... Yay!