As we said in the previous post, the first items planned for the Integrated Editor System were ways to edit image data in the webapp. That's the second major stage of the project, and it's finally finished. You can now upload, convert, and edit your sprites and images directly in the online TI-BASIC/Axe/Grammer editor!

The new features actually come in two forms. The first is an integrated sprite editor, allowing you to design your hex sprites on-the-fly. It's like a simplified version of the Pixelscape sprite editor, except that instead of showing you the code for the sprite, the code in your program is updated as you edit. Just put your cursor inside some sprite data and the sprite editor pops up automatically to show you what that sprite looks like. (It only works in Axe mode right now, but will be added to the Grammer mode soon.)

The second form is a full converter and editor for 96-by-64 images. Like with programs, you can drag-and-drop an image file of any popular image format—GIF, PNG, JPG, or 8XI (Picture variable)—and IES will open it for editing, scaling it down and converting it to calculator-friendly colors if need be. You can also create a blank image by selecting "Image" after clicking the + tab.



If you have images to convert for use in a TI-BASIC project or just to load onto your calculator, this is where IES comes in handy, with the added bonus of being able to edit and preview the converted Picture variable in two, three, or four levels. This is an image that was scaled down from 160 pixels wide and high.

Currently, the image editor is very simple. The only editing "tool" available is a pen tool that draws broken lines. Better generic image-editing tools such as rectangles, ellipses, and flood-fill are planned soon; after all, shouldn't an online image editor have at least the features of a calculator program?

It's been a while since I've finished a calculator game, and it's time to fix that. There's a game in development that's had some progress, but there's a problem—I'm not entirely sure what I'm even doing with it.

Sometimes I have an idea of what to make (such as a complete ripoff of an existing game on a different platform), and sometimes I stuff as much stuff into a program as it can hold and hope it comes out looking like some sort of game. This is the second case. I'm tentatively calling this project "Turret" because turrets will be a central factor, but it sounds pretty lame.

Here's the gist of the game. You're trapped in a series of rooms, and you want to get out through a series of doors. There are also turrets programmed to shoot at you so you don't get out.

You have no weapons of your own, but you can always try to get the turrets to shoot you in a direction you want, triggering things like dynamite crates and boulders. There are some other features that might come in handy, or kill you:

• Water levels (and swimming). There will likely be a breath count, where the player dies if he stays underwater for too long.
• Zappers. Energy fields. Instant death. Whatever you want to call it.
• Dynamite crates are triggered by turret bullets and can destroy nearby steel crates (but not solid blocks which form the wall).
• Boulders to push around. Bullets bounce off of them in various directions, which adds a skill factor, I guess.
• Coins. Collect them all to open the door!

Each of these is already partially implemented. A full level editor is also planned (and mostly complete, in fact). All this, and I haven't even figured out what the point or name of the game will be.

For me personally, no code editor will ever beat programming with a calculator in my hand. But with the ORG project I've learned that sometimes computer-based tools are more helpful. Since the token-based languages, such as TI-BASIC, Axe, and Grammer, are even more popular ways to develop programs for calculators, I've decided to work on a project to bring them online too, in a full-featured programming environment.

The Integrated Editor System will be a complete IDE for TI-BASIC, Axe, and Grammer projects. (Other languages may be supported in the future.) Though there are still many things to be added, the features I've been testing for the Axe mode already promise to make IES a far more ambitious project than even the ORG assembly IDE.

The structure of the app takes a significantly different approach from ORG. Instead of keeping a simple list of files, IES allows you to manage multiple projects, each of which can be marked for any of the three languages. Each project can then contain as many files as needed, organized by tabs similar to ORG's. To make it easier to start using the IES editor, you can just drag-and-drop your current project directly into the page—whether it's a text file, 8XP program, or even a ZIP archive!

The Axe mode already features full syntax highlighting; TI-BASIC and Grammer will sport the same colors as soon as I finish the highlighting rules for those languages. In all three modes, IES has full autocomplete and syntax hinting features (providing a tooltip to remind you of the order of arguments for a command), with data pulled from the Catalog project.

Here's what it looks like for TI-BASIC:



Of course, you can do the same thing for Axe:



And Grammer:



So what comes next? Here are some things that are definitely planned for the near future:

• Inline sprite editor (think stripped-down version of Pixelscape)
• Full image editor for 8XI and other image files
• Sharing code through the BBify'r
• Editors for real- and complex-number, list, and matrix variables
• A hex editor for binary files (such as appvars with data)

I'm still building up my list of planned features, so if you have any suggestions, please let me know!

Long story short: the ORG Z80 assembly IDE now features instruction autocompletion!

One thing that makes an editor project interesting is that when I'm working on it, I'm already working in an editor—the IDE is being built inside another IDE. What makes this situation convenient is that the little tools and tweaks I've grown so used to suddenly become inspiration for features to add to my own project.

That was the case for syntax autocompletion. With PHP naming convention being the monster it is, typing the first few letters of a function name and choosing from a list of options had long since become a familiar task. Since only certain combinations of arguments are allowed for each mnemonic in Z80 assembly, a similar feature would be even more useful for a Z80 IDE.

When you type the first part of an assembly instruction, ORG now displays a list of all valid instructions starting with that mnemonic. You can then select the option you want to avoid invalid parameters and save a bit of time. If the instruction contains an immediate value, the cursor will also move to its position automatically. (You can also trigger the hinter manually with the Ctrl-Space shortcut from Eclipse.)

Other changes made to the project over the past few months include numerous bugfixes thanks to bug reports from our users, as well as some design improvements that should make the editor load noticeably faster. If you have a suggestion or feature request of your own, feel free to comment below, post in the relevant threads, or bug me directly through email. The ORG IDE is only the first of a series of planned editor webapps for calculators here, but it will be a very active project for a while yet!

That's another year over and another apocalypse survived. Happy New Year everyone!

For me personally, this year has been amazing. So many remarkable events have turned up in my life over the past few months (in a long chain of dumb good luck) that I can't help but feel 2013 will be simply awful in comparison. But since this place is all about calculators, I'll just stick with that part of my life. There's a lot to talk about even then.

First of all, there's Fruit Ninja. I posted about it before, but there's a lot that's been left out since. A few days after the ticalc.org feature, some benevolent soul posted my video to Reddit where it had quite a reception. Now it's been hanging excruciatingly close to a million views—one short, odd episode of viralness that I'll probably never experience again.

There are also four new calculators in my collection this year after my trusty TI-83 Plus carried me through five years by itself. They're all charged up and named, and I can't wait to write stuff for them. What else could calculators be meant for?

As I said, I fully expect this new year to feel terrible simply because 2012 was such a blast. But who knows—maybe it'll be decent. Any New Year's resolutions, anyone?

In any case, happy New Year's Day to you all from ClrHome!

To make it brief, the online Catalog is a new resource that aims to document all the commands and variables in TI-BASIC, Axe, and Grammer. It'll give you the syntax and description of commands as well as the keystrokes needed to access it on a calculator. Anyone can edit it by double-clicking a section.

It also provides an API for other apps to use, available in both XML and JSON formats by appending "?alt=xml" or "?alt=json" to the end. I'll post more about this once I finish up the actual database.

And I'll admit it—at least part of the reason the Catalog project was created at all was my own laziness.

It was while working on the BBify'r for Axe that the idea came to me to create an online reference documenting all the TI-BASIC and Axe tokens. Ideally, such a reference would also expose an API so anyone who wanted to make an application that works with tokens could just query it for information that's always up-to-date. And since that sounded fun, I made it—and then realized that as long as the database didn't actually have any data, no one would ever use it.

But typing out descriptions for all 659 TI-BASIC tokens (yes, I counted) quickly becomes tedious. That's when one of the greatest ideas in business hit me: why don't I get other people to do the boring work for me?

The result was a double-click-to-edit system, something like the Wikipad, designed to entice people to do the boring work in my stead. Of course no one did it (who would?) except a few brave, kind souls who put up a significant part of the list. I tried to start adding some of it myself, but got bored again fairly quickly.

Finally, I decided to ask the people who had long before written documentation for most of the tokens: TI themselves. They were kind enough to let me use the descriptions found in the TI-83 Plus handbook, and so I spent the rest of the month copy-pasting everything from the PDF file into this Catalog. And it's just about done.

For those of you who follow our blog, you know that last year we posted a slightly comical "fake news" post about Hurricane Irene, the hurricane that swept through the East Coast. This time around, however, with the cloud of despair and destruction wrought by Hurricane Sandy, we decided to go a different route.

Hurricane Sandy was a Category 1 storm when it made landfall in Atlantic City, NJ on Monday, October 29, 2012. It caused flooding and destruction of billions of dollars worth of property in New Jersey and New York, not to mention the rising death toll, which was roughly fifty at the time of writing. It overwhelmed the preparations of both states, which are now facing what officials are calling the greatest weather-related disaster in history.

Below, you will find a few links to places where you can donate to Hurricane Sandy relief. It is desperately needed.

FEMA: www.fema.gov
Red Cross: www.redcross.org

From the beginning, Pixelscape and tileIt! seemed to be essentially the same project on two different platforms, and that's why we made sure data from one would be compatible with the other. It also means that one project can't add any notable new features without the other being involved, but this might be actually be a good thing.

One major feature request shmibs and I have taken on is the ability to create grayscale sprites and maps with our tools. It's been requested for a while now. Considering how easy it is to create three- or four-level grayscale graphics with Axe, grayscale support should have been a no-brainer from the beginning. Unfortunately, both projects were designed with monochrome graphics in mind, and the addition of grays would be a huge change.

But it's been done: Pixelscape and tileIt! both now allow sprites and maps in grayscale!

In both projects, the grayscale system is heavily tied to Axe's system of two buffers. In Pixelscape, left-click to toggle a pixel on the front buffer and right-click to toggle a pixel on the back buffer. In tileIt!, use 2nd and MODE, respectively. (To change the grayscale mode, use the drop-down menu in Pixelscape and TRACE in tileIt!.)

The one major drawback is that the data format used by the projects had to be changed. Sprite sheets created with the old versions are no longer compatible with the new ones (tilemaps should still work, however). As always, data from one project will work with the other.

Here are some other miscellaneous features that have been added to Pixelscape:

• Exporting the map as a GIF, PNG, or JPEG image
• Editing the sprite and map hex directly (allowing for easy previews of sprite data in hexadecimal form, for example)
• Sprite shifting

I've gone ahead and converted all sprite sheets people had saved online for Pixelscape to the new format. Sorry for the inconvenience; we hope you'll find the new features useful!

This spring, TI-Planet sponsored a fairly big programming competition called TI-Concours. (This is very late news. It started seven months ago and ended four months ago, and I probably should have posted about it then. Oh well—it's too late now.) The contest had three categories, and in each category participants had to create three programs. It was great motivation for me (and also for many others, I'm sure) to get some stuff done in the early months of the year.

For the first part of the Axe contest, we were asked to make a Snake game. Snake? Again? That's one of the most common simple games out there. There must be hundreds of Snake clones on ticalc.org already. I didn't want to make something that would get lost in that vast sea of snakes and worms and nibbles, so I went and made something completely ridiculous: Snake, in 3D!

And that's the story of Snakecaster, the completely overkill Snake game. I had to learn raycasting and other random stuff in order to have any idea how to make it, so it beats Minesweeper for the most effort I've spent on graphics. (By the way, if anyone out there is interested in learning raycasting, there used to be a really awesome tutorial at http://www.permadi.com/tutorial/raycast/index.html. It seems to be down now, but you can get the whole thing at the WayBack Machine. Seriously, there's something magic about that tutorial.)

The second round was to make a "Paint" program. The main goal for mine was to make it as intuitive as possible. It turned out that I never used it myself once the contest was over, but apparently some people find it still useful, so you can download it here. (Don't bother asking me for help with drawing Homer Simpson—that sample image was a product of two minutes of Google Images, Gimp, and SourceCoder 2.) I guess since 100% of my effort went into graphics in that program, it beats Snakecaster for the record amount of effort I put into graphics, in a sense.

Finally, there's Fruit Ninja. You've already seen it (I already "released it" four months ago), but I never actually uploaded it to any archive sites because there was a little bug that had some pretty nasty effects. Specifically, getting a high score would result in corruption of one byte of your calculator's RAM under certain conditions. Not too appealing for an game achievement, is it?

Well, here it is. If you don't know about it yet, watch this video of it in action. The plan was to take a game that relies on a touchscreen and somehow adapting it so that I could play it in class—yet another ridiculous idea.

Something I didn't mention was the amount of time it took me to sprite those rotating fruit. There's 1.5 KB worth of data in those 16×16 sprites, because there are four types of fruit, and each one has eight different perspectives. And it's 3D. I hate 3D. I had planned at least eight types of fruit, but by the time I realized it'd taken me more time to make the graphics than to write the code for the game,, I knew I had to stop. And that's by far the most effort I've ever spent on graphics (or will in a very long time, I'm sure).

Along the way, I actually started to enjoy making sprites, especially 8x8 monochrome ones. If you need help with some random sprites, shoot me an email or PM, because I might just do it for fun.

Oh yeah, there's also Tic-Tac-Toe, or what remains of my plans to enter the TI-BASIC section of the contest as well. It's Tic-Tac-Toe. Moving on.

The ORG assembly IDE is by far our biggest webapp, but it's also one of our most active. A lot has changed since it was first conceived late last year and first published in January. On the outside, it's gotten a complete makeover (or three): the colors changed, parts got rearranged, controls were updated, and so on. But the real improvements were in places that aren't totally visible—the places where huge sections of the project were tweaked, added, or in many cases completely rewritten.

Some of the changes are ones you can see when you take a look at the new page. There's the new theme, of course, and the new structure to go with it. The page is now divided into two visible blocks instead of four, with the editor expanded to more than half the screen area to make code easier to navigate. The tab system is still there, but much improved—some minor tweaks and transitions (inspired by the Google Chrome interface) were implemented to give them a more native-app feel, and the tab bar can finally handle more than a few tabs that would once stretch beyond the screen. The common keyboard shortcut Ctrl+S can now be used to quickly save all open files. And if the expanded code editor still isn't big enough for you, F11 will make it full-screen (and your browser too!).

The newest button added to the control bar is the (long-overdue) Open. Like with Pixelscape, it allows you to open source files (both as plain-text files and ZIP archives) or one of a set of templates. In addition, you can drag-and-drop text files straight into the page to open them (on modern browsers).

Back-end changes were mainly for cross-compatibility with a wider range of Z80 devices and programming styles. Thanks to suggestions from members at World of Spectrum and MSX.org, ORG has begun to expand its focus toward all Z80 projects. It can now assemble projects to plain binaries, ZX Spectrum TAP format, and TI-83/TI-82 STATS.fr programs, in addition to the original support for TI-83 Plus–series calculator formats, and more equate files and directives were added for compatibility.

Encompassing both sides of the project is a plan for greater language support: thanks to kindermoumoute, Matrefeytontias, and other members of the calculator community with exceedingly long nicks, most of the ORG UI has been translated to French, including all controls and log messages. All that's left is the (also updated) enormous help guide, and ORG will be fully usable in both French and English. Other languages are also being considered; if you have a suggestion—or better yet, a willingness to take on the tedious task of translation—please let us know!

Finally, for all the meta developers out there, the ORG assembler now exposes a public API for all its functions. Any platform supporting HTTP POST requests can take advantage of the API for the wide variety of compiling options ORG can handle. Basically, anything the ORG assembler can do, you can include in any apps of your own, web-based or otherwise. Sample code to use the API in both JavaScript and PHP is provided in the help manual in the ORG webapp.

We hope the updates to the ORG IDE will be useful to all Z80 developers and enthusiasts out there. Feel free to offer suggestions and comments—as I've said, this is a very active project!

A few weeks ago, shmibs and I, unbeknownst to one another, each began working on a new project. Mine was a web resource and his was a tool written in Axe, but as it turned out we were working on essentially the same idea.

tileIt! is a sprite and tilemap editor made with Axe. It means to simplify tilemap creation by first providing a robust sprite editor (with features such as rotation, reflection, and shifting), then allowing you to create a map using the sprites you make. In addition, sprites can be "played" as an animation, which should help with creating animated sprites. Your sprites and map can then be exported in a variety of formats, including as picture variables, as a TI-BASIC matrix, as Axe source, or as an appvar for transfer.

Pixelscape was a completely separate project—an online tilemap and sprite editor inspired by Aichi's now-defunct A·Sprite and A·Map. It has almost identical features as tileIt!: the same rotation, flipping, and shifting transformations, the same form of animation playback, and the same concept of using the created sprites to easily build a tilemap. It can also export in a variety of formats including picture variables, assembly source, and Axe source with optional run-length encoding. You can also copy, paste, and undo changes with the common keyboard shortcuts. In addition, when I found out how similar this was to shmibs's project, I made sure to make it compatible, so you can both upload and download sprites and tilemaps as tileIt!-format appvar files. (At one point I seriously considered renaming it tileItOnline!, but I'd already made that awesome logo.)

After completing some enormous changes to the site design last month, we realized we still hadn't tackled the biggest storm about to hit most of the known Web. No, I'm not talking about the Apple iRene. That was last year. The present threat is the smartphone apocalypse, due in three years or so. Supposedly, that's when most Internet traffic will start coming through mobile devices such as smartphones and tablets (and hopefully calculators), but unfortunately a sizable portion of the world's web sites are woefully unprepared.

And so we're joining the mobile bandwagon too. The main ClrHome site, the parts that got the facelift last month, are now completely browsable on and optimized for iOS and Android devices. Same URL, different experience—just open clrhome.org in your mobile browser and the site will basically load as a web app. There are still some minor quirks, but it should be largely functional. If you find any glitches or have any suggestions, don't hesitate to tell us!

Similar mobile optimizations should be coming soon to many of our online tools.

No, seriously. Finally, a game that essentially requires a touchscreen to play can now be played on a TI-83 Plus.

And no, my calculator does not have a touchscreen. What it does have is a rather large keypad. Convenient, isn't it? What if you could use that keypad as a sort of touchpad, swiping around in it like it's smooth? That's the idea behind this game.



The video doesn't show the screen very well, so here's an animated GIF for the graphics.



Like what you see? Download the game here, then comment below!

Wow, we haven't had a post in nearly four months. But don't worry, we've been busy making changes—lots of changes.

As I'm sure you've noticed by now, we've had yet another (yet another yet another) redesign, and this one will stick—I promise.

Along the way, we let go of our site on Blogger, moving all our news and non-news to a new system right here on the new front page. Other pages have also been moved and rearranged: instead of our classic three sections of "Projects," "Tutorials," and "Resources," the rest of the site is now divided into "Products" (the stuff we've finished), "Resources" (same as before), and "Upcoming" (things we're actively working on). Our entire tutorials collection will now count as one of our Resources, and all the other Resources have been moved to top-level directories (taking out the "/resources" in their URLs). The site has even gone mobile—just open up clrhome.org in your phone's browser.

What do you think of the changes? If you have anything to say, please comment below! (Oh, and you can use BBCode in your comments now, too.)

Our most ambitious webapp yet is now available. The ORG IDE is a complete IDE and assembler for Z80-assembly projects, particularly for those designed for the TI-83 Plus–series calculators. Featuring a tabbed interface with a syntax-highlighting code editor (by CodeMirror), you can now edit, build, download, and host Z80 projects with any number of files from any web browser.

In less dramatic news, our front page received yet another facelift. Hopefully this one sticks around.

But before we get to that, Simul 2 won first place in the extended-BASIC section of zContest 3! And if there had been a prize for largest screenshot size, Simul would have won that, too. (It was also the most difficult screenshot I've ever taken, even at 25% speed.)

And now I'm back to working on Contra. Besides making some much-needed sprite changes (more are on the way, in the name of visibility), I've also re-implemented moving enemies (which can now jump around on platforms), added swimming, and made jumping and scrolling completely smooth. Even with that, the program still has a delay to slow down each frame (on a TI-83 Plus, too), so I'm still free to add falcons and those flying football-shaped things.