[Axe] TileMap Movement
» >
»
» View previous topic :: View next topic  
I can display, save, and check the tile map.
But I can't seem to get my player to move around it, while checking for values of a square that he CAN move on.

Code:

.Drawing the map
For(A,0,11)
For(B,0,7)
If {B*12+A+L₁}=1
Pt-On(A*8,B*8,Pic1)
End
End
End

.Game Loop
Repeat GetKey(15)
getKey→K
DispGraph
Pt-On(X,Y,Pic2)
...
I was going to use this
to help with checking for
a to the adjacent spot
from where the player
will be moving.
...
X/8→A
Y/8→B

.Movement code
.This is what I was hoping to work, but it didn't.
If K=1 and {B+1*12+A+L₁}
Pt-Change(X,Y,Pic2)
Y+8→Y
End

...
The rest of the movement code
went here, but it doesn't work.
...


I'm using simple 8x8 sprites for the player and other tiles.
How would I check for the adjacent tile, and if a certain value, then move there, otherwise, do nothing?

Edit by Merth: Moved to General Programming forum, since this isn't z80 asm.
Here's how I would do it, withholding as much crazy and unreadable optimization as posible:


Code:
.TESTHELL

[FFFFFFFFFFFFFFFF]→Pic1
[FF818181818181FF]→Pic2

DiagnosticOff
3→X→Y

.Drawing the map
ClrDraw
For(A,0,11)
For(B,0,7)
If {rand^4=0→{B*12+A+L₁}}
Pt-Change(A*8,B*8,Pic1)
End
End
End

.Game Loop
While 1
DrawP()
DispGraph
DrawP()
getKey→K:TryMv()
End!If K xor 15

.Xor player sprite
Lbl DrawP
Pt-Change(X*8,Y*8,Pic2)
Return

.Try to move player according to given key value
Lbl TryMv
MvP()
Return!If {Y*12+X+L₁}
K-1 xor 3+1
Goto MvP

.Move player according to given key value
Lbl MvP
Z-Test(-1,Mv1,Mv2,Mv3,Mv4)
Return
Lbl Mv1
Yʳ++
Return
Lbl Mv2
Xʳ--
Return
Lbl Mv3
Xʳ++
Return
Lbl Mv4
Yʳ--
Return


Notes about it:
    ▪ I made the assumption that your player is restricted to tile-based movement. Hopefully this was a correct assumption, or pretty much my solution is entirely wrong.
    ▪ I changed X and Y to be stored as tile values rather than pixel values, so they're scaled down by a factor of 8. This makes the movement code a lot easier, while making the drawing code negligibly larger. Of course, this relies on the assumption above.
    ▪ Don't worry about my changes to map drawing, that was just so it worked in this test program.
    ▪ I changed the main loop to quit based on the OS getKey function instead of direct key input.
    ▪ I wasn't sure how you drew the player, but I used the trick of drawing the sprite with xor logic right before the DispGraph so it shows up, and then erasing it with the same xor logic right after. This could be done differently.
    ▪ Finally, the meat of the changes. The movement function TryMv() takes the key value passed in and calls the unconditional movement function MvP(). The MvP() function works using the nice fact that the arrow keys are contiguous from 1-4, so it is easy to subtract one from the key value to align the arrow keys to 0-3 for a movement jump table. Any other key values will fall through and not result in a jump anywhere, merely a return. Once the MvP() function has finished, it is checked if the player is now inside of a solid tile. If so, it is assumed that the player was just moved into the solid tile, so the key value is "inverted" on the range 1-4 and the unconditional movement function MvP() is called to cancel out the movement made.
hellninjas wrote:
If K=1 and {B+1*12+A+L₁}

I don't know if the problem comes from here but it may be since Axe's "and" is bitwise. This means that if {B+1*12+A+L₁} equals 2, then K=1 and {B+1*12+A+L₁} equals 0.

(got ninja'd by Runer112 but Hellninjas said that I could post anyway).
Runner: Thanks but the code itself it barely understandable from my view o_o, I get it, though. Thanks for making a description x3

Hayleia, so how would I change it..?
I know I ask a lot of questions, and want specifics. I hope it's not too difficult to put up with me :<
Here is a code that is easier to understand (but of course less optimized). Needs 1.2.1a to compile due to custom constants with names larger than 5 characters (or just change their names).


Code:
.ATEST
[]->°Map
[010101010101010101010101]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010101010101010101010101]

[]->°Sprites
[0000000000000000]
[FFFFFFFFFFFFFFFF]

.draw the map
For(X,0,11)
 For(Y,0,7)
  Pt-On(X*8,Y*8,{Y*12+X+°Map}*8+°Sprites)
 End
End

5->X->Y
While 1
 Draw()
 DispGraph
 Erase()
 getKey(1)?{Y+1*12+X+°Map}??Y++
 getKey(4)?{Y-1*12+X+°Map}??Y--
 getKey(2)?{Y*12+X-1+°Map}??X--
 getKey(3)?{Y*12+X+1+°Map}??X++
EndIf getKey(15)

Return

Lbl Draw
Lbl Erase
Pt-Change(X*8,Y*8,°Sprites+8)
Return


Another code if you really want to use the slow getKey routine instead of getKey(#):

Code:

.ATEST
[]->°Map
[010101010101010101010101]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010000000000000000000001]
[010101010101010101010101]

[]->°Player
[FF818181818181FF]

[]->°Sprites
[0000000000000000]
[FFFFFFFFFFFFFFFF]

.draw the map
0->X
For(12)
 ~1->Y
 For(8)
  Pt-On(X*8,Y++*8,{Y*12+X+°Map}*8+°Sprites)
 End
 X++
End

5->X->Y
While 1
 Draw()
 DispGraph
 Erase()
 getKey
 !If -1
  InMap(X,Y+1)??Y++
 Else!If -1
  InMap(X-1,Y)??X--
 Else!If -1
  InMap(X+1,Y)??X++
 Else!If -1
  InMap(X,Y-1)??Y--
 End
EndIf getKey(15)

Return

Lbl Draw
Lbl Erase
Pt-Change(X*8,Y*8,°Player)
Return

Lbl InMap
{r2*12+r1+°Map}
Return
hellninjas wrote:
Runner: Thanks but the code itself it barely understandable from my view o_o, I get it, though. Thanks for making a description x3

Hayleia, so how would I change it..?

You'd use the "short-circut" operators - ones that stop evaluating if the current point is true or false.

Code:
...
EXPR1 will evaluate first,
and if it is false ("?"), it will jump
to the end of the line.
Otherwise EXPR2 will evaluate,
and if it is true ("??"), it will again
jump to the end.
Otherwise, EXPR3 will evaluate.
...
EXPR1?EXPR2??EXPR3

.This transitions to and/or quite well:
.If A and B:
If A?B
.If A or B
If A??B
.If not A nor B
!If A??B
.If either !A or !B
!If A?B


I won't give you the short answer, because programming requires you to understand what's going on and solve problems dynamically.
Visit Betafreak Games: http://www.betafreak.com
Help Me Pay for College:
- Sign up for Fastweb through my referal link!
Typically speaking, one would 'center' the player on the screen, and offset the tile coordinate to adjust the map. This allows you to have maps bigger than the screen.


Code:

.draw the map around player X,Y (suggesting a 11x7 map)
For(B,Y-3,Y+3)
 For(A,X-5,X+5)
  If(A>0 && A<W && B>0 && B<H)
   .Draw tile at (A,B)
  Else
   .Draw blank tile
 End
End
.Draw player at (6, 4)

.Check movement input
.Match new X+6,Y+4 destination coordinate against tile types
.On failure, set destination to player location.
.Set player location to destination


Moving X and Y (player coordinates) would move the map
  
Register to Join the Conversation
Have your own thoughts to add to this or any other topic? Want to ask a question, offer a suggestion, share your own programs and projects, upload a file to the file archives, get help with calculator and computer programming, or simply chat with like-minded coders and tech and calculator enthusiasts via the site-wide AJAX SAX widget? Registration for a free Cemetech account only takes a minute.

» Go to Registration page
[Axe] TileMap Movement
»
» View previous topic :: View next topic  
Page 1 of 1
» All times are UTC - 5 Hours
 
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum

 

Advertisement