if math.abs(circleA.x - circleB.x) > circleA.radius + circleB.radius or
math.abs(circleA.y - circleB.y) > circleA.radius + circleB.radius then
This is checking if the AABBs of the circles are NOT intersecting. Correct would be with "<" instead of ">" and "and" instead of "or".
Besides that typo, great article, substitute! Can't wait to read more.
One question on the optimization: Did you test, if this AABB-collision-check really improves the performance? Seems surprising to me. After all, squaring numbers is not a difficult mathematical operation.
requests to josefnpat,
* please provide full length rss feeds. It will be easier to follow the blog with google reader.
* syntax highlighting would be nice too.
Awesome work, by the way
I got that snippet of code from checking AABBs if the coordinates are in the center of a rectangle. So sorry if I am wrong. But anyways, let me test it.
EDIT: I found that I made 2 embarrassing typos... I should really review my articles before posting it.
EDIT 2: Added .love file, fixed ALL my typos.
Last edited by substitute541 on Wed Mar 13, 2013 12:34 pm, edited 1 time in total.
Congratulation to our writers ! Both articles are amazing and very instructive. However, I advice to use more images. This helps comprehension, especially when dealing with 2d math.
The image Santos made in this very topic helped me a lot to understand the article, so I guess it could help any reader too.
Keep going mates! I can't wait to see what's the next article will be about!
monsieur_h wrote:Congratulation to our writers ! Both articles are amazing and very instructive. However, I advice to use more images. This helps comprehension, especially when dealing with 2d math.
If I ever write something that could use some visualization, I'll make some super sweet MSPaint style art for you all.
What are some good topics for the blog? I kind of want to write about classes in Lua, but there are really two ways you can go with this:
Essentially rewrite the PiL chapters on object-orientation, which may delve into areas that the beginner Lua audience might get scared away by. Additionally, this is a very large topic, and would probably need to be stretched out over several posts to cover everything pertinent to classes (i.e., inheritance, polymorphism, metamethods, the colon syntactic sugar, privacy, etc.);
Just pimp out one of the many great object-orientation libraries for Lua, which doesn't really teach anyone anything specific to LOVE and/or Lua.
There are many things one can talk about. Here are some suggestions (Though a lot of them have been written on other websites):
- Spatial hash/Broad phase detection
- Box/Platformer/Polygon/Tile collision
- Camera/Transforming things
- Managing assets and weak tables
- Networking
- Threading
- Coroutines
- Shaders
- dt and timestepping techniques
- Integrators
- Code organization (e.g Having a state table and each state has state.draw, state.update, etc)
- Vector/Linear Algebra math
- Tutorials where you make some game. I think tutorials like this could be good, because I think it gets people psyched, because they want to make games but they're really not sure how to go about it, and you can kind of take them through the process. I think tutorials like this might good if they were structured in a way which didn't confuse the reader, maybe starting off by defining the rules of the game they're making, how the necessary data is stored, how the logic will work, and then going into the actual code which needs to be written to make it work. Or maybe it could be done completely "naturally", maybe even in a screencast format, going through the real process of how you'd actually go about turning the game which you can see in your imagination into something which you can play, through thinking of different ways to structure things, debugging, etc.
- LÖVE from/to *insert something else here*. There are other things which are kinda similar-ish to LÖVE that I wouldn't mind exploring, like FlashPunk, NME, SDL, Flixel, Unity, libgdx, etc., but I already have Lua and LÖVE in my head, and I think that maybe it would be a lot quicker and easier for me to learn how something works by seeing how it is similar or different to LÖVE, "so, this engine uses callbacks like LÖVE, except it has this other convention for naming functions, and it can't do these things LÖVE can, but it can do these other things easily, and in this language you use these two other things instead of tables, etc."
And of course this works the other way too, introducing people to LÖVE in the context of a framework they already understand.
Or, it could help someone choose which framework/language they'd like to use for whatever they want to do.
- A look at how LÖVE works internally, an introduction to what powers the modules and a brief overview of how they work, what was chosen to power LÖVE and why, what tradeoffs were consciously made in the development of LÖVE, how the infrastructure LÖVE is built on top of affects its design, maybe even some history about how things have changed and why, etc!
- How to do things which are found in some games which might not be so obvious, like replays, splitscreen, I saw a blog post on screen shaking recently.
- Some sort of glossary? I don't really know how this would work, but maybe there are a lot of words and concepts which are used a lot which people who are new might not know? I dunno.
- Debugging?
- An overview of the IDEs avaiable for use with LÖVE (ZeroBrane Studio, Decoda, Love Studio) including what features they have and how to use them while making games.
- An indepth look into love.audio, including distance attenuation model, velocity, etc.
- If Maurice Guégan or Kyle Conroy were interested in interviews, maybe that might be interesting? Or the developers! How do they make the magic happen?
- Videos because everyone loves videos! Maybe a "HEY! You just downloaded LÖVE! Here are the answers to all of the questions you have on your mind right now!", like a quick-start video introduction.