Can it also repeat the image and stitch the ends together?

Yep, that's exactly what happens. If you draw tiles offscreen before you reach them, you can pretty much scroll infinitely in the horizontal direction.

Note that the scrolling in that video doesn't involve drawing any pixels, by the way. It'll be a bit slower if you want to have a play area wider than two screen widths, since you'll have to actually draw in the new tiles. Should still be relatively fast, though.

Well, this error is something even more basic than that, by which I mean the file failed to open at all. Perhaps you should try running makeapp.exe directly and typing in the full filepath of your ROM file.

By the way, is it possible to change the screen start to something else than 0 and 160? Because if it could be used in TI-BASIC via an ASM lib, you could set the screen just so that the drawable graph screen area takes the entire LCD width, then BASIC coders could simply use that 160x165 area to draw stuff.  (eg vertical/horizontal sprites)

Well, the partial display window output positions should always be 0 and 160 due to how the display interlacing works, but the GRAM that you display can be any 160 consecutive columns, yes. (You can even wrap around from the right side to the left side of GRAM, which means horizontal scrolling tricks are still possible.)

I just made an awesome discovery. It's possible to effectively halve the horizontal resolution of the screen on the TI-84+CSE, while still filling up the entire area of the screen, which means asm game programmers can double their framerate at a small visual cost.



This will even allow for double-buffering, where you draw to the offscreen area and then swap it in instantly, preventing flickering. My method uses partial images and interlaced output.

More detailed information on how to implement:
Enable two partial images, where one is displayed at column 0 and the other is displayed at column 160. Both partial images should be set to the same 160 columns of GRAM which you want to display. (When enabling the partial images, disable the base image.) Then turn on interlaced output (bit 10 of register 1).

Quote from: calc84maniac on March 15, 2013, 09:18:36 pm

Quote from: DJ_O on March 15, 2013, 09:16:11 pm

Darn those packages are ugly lol. I think some calcs used them around 1995 or so. I can't wait to get mine, though.

It sucks that it doesn't include TI-Connect, though. I hope that TiLP gets updated with TI-84 Plus C Silver Edition support in the meantime, otherwise people who got the calc already won't be able to transfer programs until TI releases TI-Connect 4.0 for Windows.

Actually, TI-Connect 1.6 can send/receive most variable types just fine, excluding Images and Pictures (and maybe OSes)

TI-84 Plus C Silver Edition support has been added in TI-Connect since 2004?

No, more like a TI-84+CSE follows the same protocol so it can link with 83+/84+ family calculators.

Calc, why doesn't the Gameboy logo appear before a game starts like it used to?

Because I don't boot through the BIOS anymore, it gets annoying after a while and it also might hang for some hacked ROMs.

Binary Indexed Tree, a data structure which represents an array that can both be modified in O(log n) time and retrieve the sum of any range of elements in O(log n) time. In addition, the storage requirements are no more than that of an array of the elements.

The alternatives to this method are simply keeping an array of the elements, which is O(1) for modification and O(n) for range sum, or keeping an array of the cumulative sum, which is O(n) for modification and O(1) for range sum. Binary indexed tree is the best of both methods at O(log n) for each operation, and it can be implemented in a very small amount of code.

Seriously small:
// Note that indices start at 1

// Get sum from elements 1 to k
int get_prefix_sum(int k) {
   int sum=0;
   for(; k; k-=(k&-k))
      sum += array[k-1];
   return sum;
}

// Add n to element k
void add_to_element(int k, int n) {
   for(; k<=array_size; k+=(k&-k))
      array[k-1] += n;
}
Edit: Also, here are some related helper functions.