Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.


Topics - thydowulays

Pages: [1]
1
Miscellaneous / Hey guys
« on: November 28, 2012, 10:02:52 pm »
Hey guys it's thydowulays. I haven't really been active on this forum because of school related things, irl things, etc, but I've begun to take an interest in this subject again. I have also began to take interest in French. I just feel like I needed to make an update :3

2
Web Programming and Design / Compilr, neat online IDE
« on: February 12, 2012, 10:48:23 pm »
First off, has anyone here heard of this project? I just stumbled upon this and it looks quite fantastic. It's called compilr and it is an online IDE for many languages, including C++! It has a really clean look and feel to it, and most of the functions are there. As of now, it doesn't let you compile and run your programs yet, but the admin, tim.speed says it will be up near the end of this month. This project looks really promising, it's packed with so many features it's not even funny. Check it out - http://www.compilr.com You have to sign up, but it doesn't send a request to your email, so you can get started right away!   :)

3
Well, idk if this is super hard or not, but I just had an idea.
I saw this picture of the TI89 on Wikipedia: http://en.wikipedia.org/wiki/File:TI-89.jpg
And I noticed the Cut, Copy, Paste things above 2ND [UP] and ESC.

I was wondering, since there is no ALPHA keys above 2ND, MODE, and DEL, that maybe this could be created?

I have no idea how to do this, and this is just an idea, but I bet someone from this community could know how to do it.

I mean, maybe for storing the data, you could just create an AppVar called CLIPTEMP and store stuff in there. Maybe it could be used with zStart, too (like how Omnicalc is)

Again, this is just an idea, and it would be AMAZING if it could happen :)

4
TI Z80 / Nulled-- An Axe Building/Economy game
« on: February 02, 2012, 11:46:37 pm »
Hello guys, when I'm not programming in ASM or learning, I have been working on this. I originally started this about 2/3 weeks ago (or maybe longer), and I've been working on it in little sections at a time. Anyways, so no, I'm not ripping off of TinyCraft, I actually started this before that started, whenever that was. Basically I'm going to be adding more blocks and optimizing, but here is what I have so far.

Also, about a week ago, the source was somehow deleted, so I had to rewrite the entire game. It was not good.

Blocks:
-Brick
-Sand
-Diamond
-Shop
-Lava
-Cactus

Ground tiles (not actually collidable)
-Grass
-Lava (but it causes damage)

Miscellaneous
-Day/Night switching
-When right-clicking (ALPHA) the shop, you can buy/sell bricks and sand with diamonds

Tilemap
- Nonscrolling (I REALLY want this to scroll up,down,left and right, except I have no idea how, and Metal Slug editor makes no sense)

Anyway, here is the controls:
-Move with the arrow keys
-Break blocks with the [2ND] key
-Place blocks/activate shop with the [ALPHA] key
-Switch between blocks in your inventory with
  • and [-]


Cactus's currently don't work, but they did in the version before the crash, so expect them soon!

Screenies below:
 

5
Art / Photoshop banners I did for SunkenServers
« on: February 01, 2012, 12:39:29 am »
Hey everyone, I just wanted to show you some cool art I made for SunkenServers (a Minecraft host). They said they needed a graphics designer so I decided I'd give it a go.
I made 4 banners. 3 were concepts, the last one was the good one that the owner liked.
I'll put them all in, in order.

The third concept looks identical to the final, but the final has a small Gaussian blur bound to it.

I hope you like them!

P.S. Tell me which one you like the most! Also, if you need something like this done, I can do it for you, for free!


6
Other Calculators / I Sincerely Apologize
« on: January 30, 2012, 10:52:04 pm »
Hello Everyone. I tend to do these (I just don't catch myself that often) but this one was really bad. I tend to make broad generalizations of lot's of things, especially when I haven't been sleeping recently or have been deprived or sleep. I just want to say I apologize for a comment in IRC that I posted about TI-BASIC being "Slow and Obnoxious" and how I didn't like TI-Basic games. This was a very snide and poorly spoken comment and I apologize if I may have offended anyone in saying this. I take full responsibility for my actions and I do not expect any individual in this community to forgive me for this, as it was rude and uncalled for. My Deepest Apologies, thydowulays.

7
Axe / thydowulays's Complete n00bs guide to Tilemapping in Axe
« on: January 25, 2012, 10:41:16 pm »
Okay, so you've seen them everywhere. Mario, Pacman, and tons of others all use a method for displaying a "map" on the screen, and easy and custom collisions with it. Although there are many out there, this Axe tilemapping tutorial will hopefully boost your knowledge of tilemapping to a pretty decent level. Enough of me blabbering, let's get started!

Okay, so the first part of the tilemap is the map itself. Most maps are 12 wide, and 8 tiles high. Tiles are 8x8 sprites that are used in a tilemap, that can be collided with, drawn, or changed dynamically. You will learn how to do all this later on in the lesson. NOTE: This lesson only covers non-scrolling tilemaps.

When drawing a map, you have to pay attention to the number that the tile is. This will always be two digits in length, and the numbers in it correspond to the sprites that you put in the tile. For example - tile 00 is blank, while tile 01 would hold a sprite value.

Here is an example of a map:

[010101010101010101010101]->GDB1 // You will learn why this is on top later
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000010101]
[010000000000000001010101]
[010101010101010101010101]


The reason we put the GDB1 at the top, is because that ensures that our map compiles like it should, without doing that will only display one row of the map.

That map is 12x8, because there are 24 numbers in each row (remember that one tile is two digits) and there are 8 columns.
The map would look like this drawn:

XXXXXXXX
X           X
X           X
X           X
X           X
X      XXXX
X    XXXXX
XXXXXXXX

However, we haven't even defined what 01 is yet! This is what we will be doing now:

NOTE: The tile number 00 will ALWAYS be an empty tile, any numbers after that YOU will have to define yourself.

To add a tile to a tile map, you simply define a certain sprite. We will be using Pic1 for this, as it is easy to understand.

Here is an example:

[010101010101010101010101]->GDB1 // Same tilemap as earlier
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000010101]
[010000000000000001010101]
[010101010101010101010101]

[FFFFFFFFFFFFFFFF]->Pic1 // A simple black block sprite. How does it know which picture variable to use? We will be learning that next.


Basically, that code makes every tile labeled "01" a block sprite. Every tile labeled "00" is an empty one.

How does it know which picture variable to use?

When you actually draw the tilemap using a routine I will give you, there is a line in the routine that is this: Pt-On(A*8,B*8,T*8+Pic1). Just replace the Pic1 with whatever picture variable you chose.

However, we will not be doing the routine until later. Right now I will focus on adding more than 1 tile sprite.

This is how it's done:


[010101010101010101010101]->GDB1 // Same tilemap as earlier
[010202020202020202020201] // Now just add 02 as the tile, and the second sprite will show up
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000010101]
[010000000000000001010101]
[010101010101010101010101]

[FFFFFFFFFFFFFFFF]->Pic1 // A simple black block sprite. How does it know which picture variable to use? We will be learning that next.
[0F0F0F0F0F0F0F0] // We only put the ->Pic1 on the first tile sprite, everywhere else it is not needed.


So now, the sprite [0F0F0F0F0F0F0F0F] can be treated as 02, so wherever you put 02 in your tilemap now, [0F0F0F0F0F0F0F0F] will show up there.

You got that down? I think you need a visual. Say that 01 was a smiley face, and 02 was a frowny face. This is what the example up there would do:
:) :) :) :) :) :) :) :)
:) :( :( :( :( :( :( :)
:)                         :)
:)                         :)
:)                         :)
:)                 :) :) :)
:)             :) :) :) :)
:) :) :) :) :) :) :) :)
Kudos for Qwerty.55 for fixing my smiley map :)

Thats all for defining tilemaps, now we need to draw them. I like to use a simple, yet flexible routine for this. Here it is (don't be intimidated, it's not that confusing)


<Insert tilemap here>
Repeat getKey(15) //Tilemap will show until user presses CLEAR
For (B,0,7) // This statement here will take care of drawing the tiles from top to bottom. The number at the end is always one less than the height of the map
For (A,0,11) // This statement takes care of drawing the left to right tiles.
{B*12+A+GDB1}->T // This turns the actual tilemap data into the picture for the tilemap. NOTE: If your tilemap isn't 12x8, change the 12 in this to whatever it is.
If T //Don't mind this, but you must have it in your code
T--
Pt-On(A*8,B*8,T*8+Pic1 // This actually draws the tilemap. Replace Pic1 with whichever variable you defined your tile sprites with earlier.
End
End
End
DispGraph //Displays the tilemap
ClrDraw
End


I know that may seem a bit intimidating, but give it a try!

And now a finished (sort of) product:

[010101010101010101010101]->GDB1
[010202020202020202020201]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000010101]
[010000000000000001010101]
[010101010101010101010101]

[FFFFFFFFFFFFFFFF]->Pic1
[0F0F0F0F0F0F0F0]

Repeat getKey(15)
For (B,0,7)
For (A,0,11)
{B*12+A+GDB1}->T
If T
T--
Pt-On(A*8,B*8,T*8+Pic1
End
End
End
DispGraph
ClrDraw
End


You can also store your tilemap in a second program. Such as this


PROGRAM:TILEDATA
[010101010101010101010101]->GDB1
[010202020202020202020201]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000010101]
[010000000000000001010101]
[010101010101010101010101]

[FFFFFFFFFFFFFFFF]->Pic1
[0F0F0F0F0F0F0F0]

That would be called prgmTILEDATA, now all you have to do is put it in your main program. (We will be using prgmTILESRC)


PROGRAM:TILESRC
Repeat getKey(15)
For (B,0,7)
For (A,0,11)
{B*12+A+GDB1}->T
If T
T--
Pt-On(A*8,B*8,T*8+Pic1
End
End
End
DispGraph
ClrDraw
End
Return //Always put a return statement before you include any subprograms
prgmTILEDATA //Now it should work the same as before, just less crowded.


Anyways, that's all fine and dandy, but what if we wanted a player that would be able to walk through one tile, and not be able to walk through another?
It's actually pretty simple.

PROGRAM:TILESRC
48->X
40->Y
//Simple variables to store the position of the player that you can move.
Repeat getKey(15)
For (B,0,7)
For (A,0,11)
{B*12+A+GDB1}->T
If T
T--
Pt-On(A*8,B*8,T*8+Pic1
End
End
End
Pt-On(X,Y,[FFFFFFFFFFFFFFFF]) //Displays a block sprite at position X,Y
DispGraph
ClrDraw

If getKey(4) //If the user presses the Up arrow
Y-8->Y //Move the player one tile up
Pause 500 //Make it a little slower
End

If getKey(1) //If the user presses the Down arrow
Y+8->Y //Move the player one tile down
Pause 500 //Make it a little slower
End

If getKey(2) //If the user presses the Left arrow
X-8->X //Move the player one tile left
Pause 500 //Make it a little slower
End

If getKey(3) //If the user presses the Right arrow
X+8->X //Move the player one tile right
Pause 500 //Make it a little slower
End


End
Return
prgmTILEDATA


That adds basic movement for a block sprite. Now I will be showing you a simple, yet effective routine for getting individual tiles. (Thanks, leafy :) )
Add this right after prgmTILEDATA:

Lbl GT
{r2/8*12+(r1/8)+GDB1}
Return

Basically, that routine tests to see if there is a tile at position X,Y. You can also test its number, like if it's a 01 tile or not.

Here's how you would add collision:


PROGRAM:TILESRC
48->X
40->Y
Repeat getKey(15)
For (B,0,7)
For (A,0,11)
{B*12+A+GDB1}->T
If T
T--
Pt-On(A*8,B*8,T*8+Pic1
End
End
End
Pt-On(X,Y,[FFFFFFFFFFFFFFFF])
DispGraph
ClrDraw

If getKey(4)
!If sub(GT,X,Y-8)=1 If there is NOT a tile with a number of 01 directly ABOVE the player, then move.
Y-8->Y
Pause 500
End
End

If getKey(1)
!If sub(GT,X,Y+8)=1 If there is NOT a tile with a number of 01 directly BELOW the player, then move.
Y+8->Y
Pause 500
End
End

If getKey(2)
!If sub(GT,X-8,Y)=1 If there is NOT a tile with a number of 01 directly to the LEFT of the player, then move.
X-8->X
Pause 500
End
End

If getKey(3)
!If sub(GT,X+8,Y)=1 If there is NOT a tile with a number of 01 directly to the RIGHT of the player, then move.
X+8->X
Pause 500
End
End

End
Return
prgmTILEDATA
Return
Lbl GT
{r2/8*12+(r1/8)+GDB1} //Our routine for testing tiles.
Return



Whoo! That's a lot of code! But, If you did it correctly, you will notice that you can't move past the solid black tiles! Let's take a second to study this line:

!If sub(GT,X,Y-8)=1

How does that line work? Well, the ! tests to see if it is NOT there, and the If sub(GT,X,Y-8) tests to see if there is a tile directly above the player, and the =1 after that tests to see if the tile's number is 01. If it said =2, then it would test to see if the number was 02. Simple stuff.

You can use this simple tilemapping frameworks for lots of games, including platformers (with a little modification) as it is easy and effective.

Thanks so much to Runer112, aeTIos and Leafiness0 for teaching me tilemapping, and your routines!

I hope you found this tutorial helpful, leave any questions or comments below.

I will be uploading some screenshots to go with this tutorial soon, but in the mean time, have fun with this!

8
Hey everyone, it's been a while. Anyways, I've been working on a building/economic game sort of similar to minecraft, but I really want to implement scrolling. I don't want it to scroll a pixel at a time, I want it to be a tile. I would also have the player *not* stay in the middle when scrolling, because I already have a perfect movement and collision engine. Thanks for all your help!

9
ASM / So what next?
« on: January 09, 2012, 10:14:10 pm »
So, I must say I am quite happy to announce that I have successfully completed Hot Dogs ASM tutorial and ASM in 28 days. It's cool and all, but I don't really know where to go from here. Would anyone suggest anything? I don't know how to do sprites yet and ASM in 28 days' tutorial on it is too difficult to understand. If you know anybody that can help with this, could you please? I would really like to start making ASM games, as the ASM section is declining quite badly and I'd like to see more than 1-2 projects in the works :) Also, does anyone have any simple source code for a simple game I can see? Thanks so much everybody here, I am no longer restricted to just BASIC or Axe, but now I know a lot more. Sincerely, thydowulays

10
Axe / Help with tilemap collision?
« on: January 08, 2012, 12:44:06 am »
Okay, so I have a simple problem. I am making an RPG, and I have a tilemap. pxl-Test(ing doesn't work for tilemaps, so I just want to know how to find tiles on the map and if they are "solid" then don't let the player move. Here is my code:
Code: [Select]
.LOLZ
prgmLOLZDATA <-- My tilemap and sprites are stored in here
0->X->Y
Repeat getKey(15)
For(B,0,7
For(A,0,11
{B*12+A+GDB1}->T
If T
T--
Pt-On(A*8,B*8,T*8+Pic1
End
End
End
DispGraph
ClrDraw
If getKey(4)
Y-1->Y
End
If getKey(1)
Y+1->Y
End
If getKey(2)
X-1->X
End
If getKey(3)
X+1->X
End

End
Return


11
TI Z80 / Sparta 2.0b GUI Library [With DoorsCS 7 style GUI available]
« on: January 03, 2012, 06:53:43 pm »
Hey everyone! Yes this is a new thread, I couldn't manage to change the title of my old thread and this is a completely brand new library then before. Inspired by BuilderBoy's Zedd Physics library, the Sparta GUI Library has an extensive range of GUI objects to choose from. From frames to checkboxes, this library has a lot to offer.

Let's start with the commands:

CLR() : Added for simplistic clearing with less keystrokes. (same thing as doing ClrDraw and ClrDrawr)
BUFF() : Added for simplistic drawing with less keystrokes. (same thing as doing DispGraph and DispGraphr)
DRF("String of Text") : Draws a DoorsCS style framed window with an X button. The "String of Text" is displayed on the top bar.
DRB(Xpos,Ypos,Width,Height,"Text inside button", 1) : Draws a button (will be DoorsCS style soon) at positions X and Y, with Width and Height. The 1 at the end represents whether the button is inverted or not. If it is, put a 1 at the end. If it isn't, put a 0
DRDIA("Title on top","Stuff inside 1", "Stuff inside 2", "Stuff inside 3", 1) : Draws a DoorsCS style dialog box in the center of the screen. The 1 at the end represents whether the dialog is enabled or not.
DRCH(Xpos,Ypos,"Text",1) : Draws a DoorsCS style text box at position X and Y. The 1 at the end is whether the box is checked or not.
DRM(Xpos,Ypos) : Draws a DoorsCS style mouse pointer (all black) at position X and Y.

More commands will be coming soon as the library is still in beta.

Example program using Sparta:

Code: [Select]
.GUITEST
46->X
26->Y
Repeat getKey(15)
CLR()
DRF("Window")
DRB(25,20,25,10,"Button",1)
DRM(X,Y)
BUFF()

If getKey(4)
Y-1->Y
End
If getKey(1)
Y+1->Y
End
If getKey(2)
X-1->X
End
If getKey(3)
X+1->X
End
End
Return
prgmSPARTA

A more extensive GUI example can be found below (prgmFAKE)

Known Bugs:
- Program will slow down significantly when a dialog box is present
- (Fixed) GUI objects would randomly disappear

Feel free to leave your feedback below! (Please keep it unbiased)


12
Axe / Axe TextBox input?
« on: December 24, 2011, 12:56:21 pm »
Hey omnimaga, I am working on a GUI library atm, and I want to add a TextBox feature to it. This would be very useful because people could use this feature for their programs, and the Axe input function isn't exactly perfect. So I want to make it a little like the DoorsCS Text input. I already know sort of how to do it. The command to draw the TextBox would be DRTXT(Xpos,Ypos,Width,Enabledornot) I would have a gray line at Xpos+1, so it would be the cursor, like in DoorsCS's TextBox. So anyway, I would use a variable that would represent where the cursor would be (it would start at Xpos+1). Now everytime someone would press an alphabet key, the variable would go up 4 pixels, and the cursor would move. Then I would use a Text(CursorVariable, Ypos+1, "whateveralphabetkeyletteritsassignedto") at that position. When all this works out, I would have a working textbox that people could type in. However, does anyone know how I could make a string out of their text? I can't figure it out at all. Thanks :)

13
TI Z80 / Sparta GUI Library *Alpha*
« on: December 20, 2011, 11:36:35 pm »
Hello omnimaga, it's thydowulays here! I have decided to make a complete GUI library for Axe with (I'm planning to) have every GUI feature that is in DoorsCS 7. This project currently has:

- Perfect flickerless drawing and a legit library
- Several commands
- Only one program needed to use the library, just add prgmSPARTA at the bottom of your project after the Return statement

The commands are as follows: NOTE that commands with a * are still in development and are not featured in the Sample project for a reason.

DRF(r1) - This command draws a frame with r1 being a string. r1 is drawn to the top of the frame, as a title
DRB(r1,r2,r3,r4,r5,r6) : This command draws a button. r1 is the X position, r2 is the Y position, r3 is the button width, r4 is the button height, r5 is the text in the button, and r6 is a boolean (0 or 1), 0 making it a normal button, 1 making it an inverted button
DRM(r1,r2) : This command displays a mouse on the screen at positions X(r1) and Y(r2). I recommend you replace the r1 and r2 with a variable that you can change with getkey(1 2 3 and 4) statements.
CLR() : This command is added at the BEGINNING of your Repeat loop in your program or whatever your main loop is for no flickering
BUFF() : This command buffers the objects on the screen, and passes through the CLR() command to make them update, or move
DRDIA(r1,r2,r3,r4,r5) : As of Update #1, this command is finished. It displays a message dialog on the screen much like in DoorsCS 7.

This is indeed a library, not a program with subroutines in it.

First library release, sample project, and screenie are below. Tell me what you think of it! :) P.S. prgmSPARTA is the actual library, prgmTEST is the Sample project

Update #1 is out! Link here: http://ourl.ca/14569/273147


14
TI Z80 / Grapher
« on: December 17, 2011, 05:22:13 pm »
Hey everyone! So I have been hanging out at my friends house and *pwning* his calculator. For the past hour I have been working on a graphing program for geometry. So far I have a GUI, graphing with lines, intersecting lines, and rectangles. (Keep in mind this project is only an hour old) Anyway, it is completely flickerless and so far the only grayscale is behind the X button. I will regularly update this post with all the things I add, and I will ALWAYS post a screenie  :D. This is what I have planned for this project:

- Flickerless movement and point plotting (Done)
- GUI (Done)
- Slope display in the corner
- Much more options
- Gray grid lines behind the screen to make it look like a graph (Done)

Update 1 is out! Link: http://ourl.ca/14522/272130

Anyways, if you have any problems or suggestions, feel free to post them below. Thanks :)

Screenie:


Download link for source and executable below:

15
Introduce Yourself! / Well, I guess I'd better.....
« on: December 10, 2011, 06:14:02 pm »
Hello, everyone. I've been on this community for a few months and I think I already have a post, but I haven't really made any ones so I'll introduce myself. I am thydowulays, and I am a skilled programmer at Java and Objective C, but I'm currently learning Axe on the calculator so I can actually have SOME fun in Geometry class. Anyways I am working on a project on Axe that allows you to draw your own lines, rectangles, circles, and pairs of lines, and it will tell you everything about them. I currently have the GUI done, and the line, crossline, and some of the Rectangle done. I might release it on here so maybe someone can help me, but I don't know if it is good enough yet. Thats me. Thanks  :)

Pages: [1]