The image here is a mockup of the title screen to the upcoming game Maximum Security. As with a lot of other things in the game, the highlight around START will be another unnecessary animation in the actual program, which I'm working on now. This idea got big fast—it was originally meant to be a quick little project to prove I'm still alive, and here we are a year later!

As promised, here's a screenshot of MaxSec. (Don't you just love CamelCase?) It's not entirely new (having been taken two weeks ago), but it's certainly an update on the last one.

Since there's a lot going on in this screenshot, here's a quick run-through of the things that the player encounters in traversing the demo level:

• Water starts pouring into the upper part of the level.
• Turret (aimed at the player) launches a bullet.
  • Bullet strikes a boulder and bounces off.
  • Bullet strikes a dynamite crate, which triggers a chain reaction, clearing the level.
  • Water from upper part of level can now flow down the new corridor.
• Player pushes boulder onto turret so it's safe to walk by.
• Player collects coins, opening the exit door (which changes visibly).
• As player is underwater, his breath count (white "health" bar on the right) drops bit by bit. (Kinda proud of that bubble animation myself.)
• As water covers the entire map, it leaves some air pockets which player uses to replenish his breath count.

The water behaves a bit oddly in this level, but anything I try to fix the water algorithm seems to leave me with a fantastic RAM clear. I'll probably just design levels in a way that it doesn't look quite as odd, or call it something other than water. Why not acid?

So here it is—our latest major project. More screenshots are yet to come as the remaining parts of the project get finished!

Before we get any further, here's the download link. (It's a multipurpose unit converter, in case you didn't get the hint.)

Look, I know there are tons of helpful little programs on ticalc.org, and many of them do exactly the same thing. I realize that unit converters are a lot like the many other types math/science utilities swamping ticalc.org. Just like quadratic solvers, these things have so burdened the famous calculator file archive that there's a whole category dedicated to them, all in TI-BASIC and all for the TI-83/84 Plus series. (For the record, I have a quadratic solver there too—click if you dare.)

But this one is hopefully different. It was made to pack as much stuff in as small a package as possible, so here's a single, 2,977-byte program that has 132 units spanning 15 different categories:

Length Area Capacity/volume Mass Speed

Pressure Energy Power Force Temperature

Charge Current Radiation Time Angle

Thanks to math, I can claim this program supports 1,170 different conversion functions in less than 3 KB. And there you have it—yet another unit converter to grace the halls of ticalc.org.

If you've seen any list of the games I've worked on, you know that what I really love making are puzzle platformers. They're even more fun to make in Axe, where there's plenty of speed available for a nice physics engine.

Well, despite the Contra project still being in a sort of limbo state, we announced a new game tentatively called "Turret" back in January. It would be the dogpile of all that's fun to work with in a platformer, with features such as water levels, dynamite, and movable boulders. And turrets—lots of them, and lots of bullets to come with them.

But "Turret" was just a working title, and it didn't come with a decent storyline. Thanks to codebender on Omnimaga, however, the game now has both a real title and a real story!

Trapped in a maximum-security prison against your will and without knowing why, your fate is changed by an explosion that rips open your cell. All of the guards and other inmates have mysteriously disappeared, leaving you alone to find your way out of the compound.

Passing through room by room, your journey is fraught with dangerous equipment and materials once meant to keep prisoners in check. You must navigate around vaporizing laser arcs, falling stacks of boulders, exploding crates of dynamite, gun turrets that track your movements, and dangerous liquids pouring through the walls and threatening to drown you.

There are no weapons or tools at your disposal. All you have is your own ingenuity; use it to manipulate the hazardous equipment in each level to serve your own ends, to help you escape. Find your way through the corridors and discover what happened to the compound—and why you were taken there in the first place.

Fresh animated screenshots of Maximum Security are coming soon!

While BBCode may be one of the most popular languages for forum post authoring, not everyone posts their code on forums. Since HTML is a much more widely used markup language for the web (and BBCode compiles to HTML anyway), making the BBify'r prettify your code as HTML has been one thing I've been planning to do for a while.

The feature has finally been added: the BBify'r project, which was first announced two years ago as a webapp to syntax-color your calculator code to as BBCode so you can paste it in a forum, now generates HTML (and a live preview!) so you can paste it anywhere else. It works with all the languages the BBify'r has always worked with. Z80 assembly, Axe, TI-BASIC, and Lua are there by default, but you can always easily create your own language rules using the BBify Builder tool (which I apparently forgot to post a news about).

The only problem now is that the name of the webapp no longer means anything. It's not just BBCode anymore!

Our online TI-BASIC/Axe/Grammer IDE just got a major update. Among the new features are editors for 8XL (List) and 8XM (Matrix) variables, as seen in the screenshots on the right.

As always, you can either drag-and-drop an appropriate file into the webapp or create a new list or matrix using the + tab. Both editors take the form of a simple chart, allowing you to edit list/matrix elements individually or the entire structure at once, using TI-BASIC syntax (such as {1,2,3,4} for lists and [[1,2][3,4]] for matrices).

Try it out here, and if you have any questions, bug reports, or suggestions, feel free to post below!

It has been a while since Kerm Martian revolutionized the Texas Instruments calculator community with his CALCnet software and the global CALCnet protocol, which was the first step towards allowing TI programmable calculators to use the Internet. Several months later, CALCnet is the most widely used networking protocol for performing calculator-to-calculator communication, as well as calculator-to-Internet communication. It has been used in games (like "Obliterate"), chatting programs (like "CHAT"), a fledgling browser ("Gossamer"). Many more are on the way.

Kerm has announced that he intends to redesign CALCnet to make it more feature-rich and to possibly remove the need for software to be running on a computer. Currently, you need to have a program running on your computer while your calculator is plugged in to access the Internet. While CALCnet currently has no vulnerabilities, when these changes are made, some may be introduced that would allow others to send "malware" to your calculator.

Why, you may ask, would someone do this? Well, there are some people who would do it just because they can. Or a jealous classmate who wants to do better than you on a test and decides to install something that will mess with your calculator's mathematical ability (changing the number of decimal places it rounds to, or making all answers off by a certain percentage). For your information, these types of "malware" already exist, as pranks, but require physical access to the calculator you want to install them on. But CALCnet may change that as it develops. Every new technology can be used for evil.

So, I endeavored to create a Firewall and Malware detector. This program will intercept CALCnet packets and check the sender ID against a list of blocked calculators. If the sender is on the list, the packet gets cleared immediately and never reaches your calculator. For now, you will need to add and remove entries from your block list manually, but when I learn about the new CALCnet design, I will endeavor to allow this program to automatically connect to CALCnet, and download a block list filled with "known threats".

My program will also have a malware scanner. "Prank" programs that can actually cause your calculator (or your grades) harm, such as the OFFBY1 virus (a program that makes all answers be off by plus or minus 1), will be scanned for, as well as tidbits of code that can cause physical hardware damage. These will be included in a "virus definitions file" that comes with the program. For now, you will need to check the site for updates yourself, but again, once I learn about the new CALCnet design, I will endeavor to have this program update the virus definitions automatically.

Check out my project page for more: http://clrhome.org/blastav/.

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!