So I was thinking of making a new game, based around a single gameplay mechanic: light and shadows.
I was planning on making a rogue-like game (where you descend endlessly down a randomly generated dungeon, finding treasures, killing monsters, and avoiding traps and whatnot).
I decided that it would be cool to add light and shadow to the game, so that it's like you're in a DARK dungeon, emanating light (and it's scary - what could be lurking around the next corner?)

Sadly, it's extremely slow - this is an Axe assembly program going at full speed on an TI-84+SE, and moving the circle feels like pulling teeth.

Any optimization suggestions, please?
(I'm using a variant of Bresenham's line algorithm, for those interested)

Also: how fast does pxl-Test work?  And the line( command?

.LIGHT
Full
DiagnosticOff
Fix 5
Fix 9
Fix 0
ClrDraw
ClrDraw[radians]

[FFFFFFFFFFFFFFFF]->PIC1
[3844828282443800]->PIC2
45->A->B
0->C
sub(MAP)
Pt-On(A-3,B-3,PIC2)
DispGraph
::While 1
If getKey(15)
Goto END
End
getKey(1)-getKey(4)->E
getKey(3)-getKey(2)->D

If D or E
ClrDraw
A+D->A
B+E->B
sub(MAP)
For(C,0,64)
sub(LIN,A,B,96,C)
sub(LIN,A,B,0,C)
End
For(C,1,95)
sub(LIN,A,B,C,64)
sub(LIN,A,B,C,0)
End
Pt-On(A-3,B-3,PIC2)
0->C
DispGraph
:End

::End

Label MAP
For(F,0,7)
For(G,0,1)
Pt-On(G*16,F*8,PIC1)
Pt-On(G*16+72,F*8,PIC1)
End
Pt-On(F*8+16,0,PIC1)
Pt-On(F*8+16,56,PIC1)
End
Pt-Change(16,24,PIC1)
Pt-Change(72,32,PIC1)
For(F,0,1)
For(G,0,1)
Pt-On(F*24+32,G*24+16,PIC1
End
End
Return



Label LIN
If abs(R4-R2)>abs(R3-R1)->U
expr([degrees]R1,[degrees]R2,2)
expr([degrees]R3,[degrees]R4,2)
End
R1>R3->K
abs(R3-R1)->S/2->V
abs(R4-R2)->T
R2<R4*2-1->W
R2->Y
For(Z,R1,abs(R3-R1)+R1)
If K
2*R1-Z->X
Else
Z->X
End
getKey(15)*9+W->W
ReturnIf getKey(15)
If U
If pxl-Test(Y,X)
Line(Y,X,R4,R3)
Return
End
Else
If pxl-Test(X,Y)
Line(X,Y,R3,R4)
Return
End
End

V-T->V
If V>99
Y+W->Y
V+S->V
End
End
Return

Label END
Fix 4


So is it kind of like a birds-eye-view 3D adventure type game? It looks cool, I hope you get the speed worked out

That looks awesome!  By the way, if you think you can read the algorithms, there's this wonderful program: http://www.ticalc.org/archives/files/fileinfo/226/22637.html
I love that game on my 86.

Here's the source: http://www.ticalc.org/archives/files/fileinfo/226/22638.html

Oh, those are shadows! I totally thought those were like columns coming up at you That makes more sense now about the light thing. Ya, gray shadows would be cool

I think the algorithm is to allow a straight line to be drawn from the player to the next pillar (or from the pillar to the edge of the screen)  Qwerty is kinda right though, there is already a line routine written in ASM, if you can get the code for that routine and edit it apropriately, you can get the same routine but 9001% faster.  Quigibo released the source a long time ago, so you might want to look for it, if you (or anyone) can't find it, I'll edit my post.

Quote from: Michael_Lee on October 17, 2010, 10:40:42 pm

Any optimization suggestions, please?
(I'm using a variant of Bresenham's line algorithm, for those interested)

It looks awesome, but why are you using that algorithm? It could very well be faster to set the initial screen and adjust the start/end points of the Line( function (which already uses Bresenham's algorithm).

I'm using the algorithm to test when the shadows should start.  The algorithm tests all the points in the line, and when it encounters a black pixel, it switches over to the built in line( function to draw it.

--
Okay, grayscale it is!
--
Anybody know where I can find a TI-86 emulator?  I wanna try Blinded by the Dark.

It makes it prettier

Actually, it just occured to me that it'd be *really* easy to add greyscale with the way greyscale is currently set up.  Store the layer you get from here, to the backbuffer, and copy-pasta the main image that you are doing collision tests with to the front buffer and blamo!  Greyscale shadows