To explain the function:
If I were to do something like the following:
| code: |
for x : 1 .. 10
for y : 1 .. 10
code
end for
end for
|
It would execute "code" 100 times. If "code" was some code to check whether (x,y) on a grid is true or false or whatever, it would check a square of 10x10.
In my function, the x forloop is checking from x1 to x1 plus the width of the object. x1 will be mage1x, which is used to draw a picture. Pictures are drawn with their bottom left corner at (x,y). Thus, x1 is the left side of the picutre. x1+ obj_width is the right side of the picture. Thus, the X loop is checking the entire width of the picture.
This doesn't help, though, unless there is a y component to the checking. The Y loop checks from y1 + check_under_obj, to y1. check_under_obj is just some number. Say it's 5. So, it checks from y1 - 5 to y1. Again, Pic.Draw draws the pic with its lower left corner at (x,y). So, y1 is the bottom of the pic, y1 + check_under_obj is a little more complicated. check_under_obj is designed to use the y velocity of the object. Since we're checking for a GROUND collision, vy will be negative, since the mage is moving down, towards the ground. So, y1 + check_under_obj (a negative number) equals a number less than y1. Thus, the ycheck loop checks from a bit under y1 (in relation to the velocity of the player) to y1.
Together, these two for loops check in a grid underneath the mage.
If your mage is travelling with a y velocity of -5 (5 pixels per loop down), the fnc will check in a grid from one side of the pic to the other, and from the bottom of the pic to 5 under the pic. Thus, there is no way that a ground pixel could be skipped over. If the check_under_obj value were hardcoded, to, say, 3, and the mage was travelling down with a velocity of 10, it could be skipped over.
ex: mage is at 100, travelling -10. there is a ground pixel at 93. ground_collision checks a grid from one side of the pic to the other side, and from 100 to 97 (100 - our hardcoded value, 3). The ground pixel is not noticed. Next time through the loop, the mage is at 90 (100 - his velocity, 10). He has passed through the ground pixel! That shouldn't be, and that whole use of velocity in checking the grid is designed to prevent that.
The simpler part of the function is the whatdotcolour, which simply uses that grid that the for loops made for us. It goes through the for loops (the grid) and checks for a ground pixel. If there is one, then it returns true, there was a ground collision. If the for loops complete and it the whatdotcolour line returned false each time, then the ground_collision function returns false, there was no ground collision.
If that makes sense, I made an even more complicated function (well, set of functions) for you. 
| code: |
module Collision
export below, above, left, right
function below (x : real, y : real, obj_width : int, check_under_obj : real, coll_colour : int) : boolean
for xcheck : floor (x) .. ceil (x) + obj_width
for ycheck : floor (y) + floor (check_under_obj) .. ceil (y)
if whatdotcolour (xcheck, ycheck) = coll_colour then
result true
end if
end for
end for
result false
end below
function above (x : real, y : real, obj_width : int, obj_height : int, check_above_obj : real, coll_colour : int) : boolean
for xcheck : floor (x) .. ceil (x) + obj_width
for ycheck : floor (y) + obj_height .. ceil (y) + obj_height + ceil (check_above_obj)
if whatdotcolour (xcheck, ycheck) = coll_colour then
result true
end if
end for
end for
result false
end above
function left (x : real, y : real, obj_height : int, check_left_obj : real, coll_colour : int) : boolean
for xcheck : floor (x) + floor (check_left_obj) .. ceil (x)
for ycheck : floor (y) .. ceil (y) + obj_height
if whatdotcolour (xcheck, ycheck) = coll_colour then
result true
end if
end for
end for
result false
end left
function right (x : real, y : real, obj_width : int, obj_height : int, check_right_obj : real, coll_colour : int) : boolean
for xcheck : floor (x) + obj_width .. ceil (x) + obj_width + ceil (check_right_obj)
for ycheck : floor (y) .. ceil (y) + obj_height
if whatdotcolour (xcheck, ycheck) = coll_colour then
result true
end if
end for
end for
result false
end right
end Collision
|
Other than the module, I changed the functions around a bit. I made it so they input real values, instead of integers, and modified the real values inside the function. Thus, using the function in the actual program is easier.
I also made use of the floor and ceil functions. Logically, I think there may have been a possibility, though negligable, that a collision would be missed. I believe that, with the use of floor and ceil functions, I have eliminated that possibility. |
i apologize if you dont understand my variable names, but i can always clear that up if you need me to.
