Quote:
So, I would like some opinions on how I should handle luckytime.
For example, I can either enumerate through players within a screen, and check for distance and check for llucky time. If a player is within range for luckytime, they start luckabsorb.
Now option B tht I have. When a player starts luckytime, its in a 7x7 grid. Now the tiles within that 7x7 grid, get an attribute declaring them luckytime tiles, a blessed tile if you will. When player is standing still on a blessed tile, they start gaining luckytime.
Which of these would be the smarter more efficient route. Or if you have another, better way, I would love to hear.
int base_X = 10, base_Y = 10;
int lowerX= base_X - 3, lowerY= base_Y - 3;// Lowest possible coordinate value.
for (int x = lowerX; i < lowerX + 6; x++)//Enumerate through all possible X values.
{
for (int y = lowerY; j < lowerY + 6; y++)//Enumerating through all possible Y values.
{
map.SetBlessedTile(x, y);
}
}
Assume that Hero A is standing at 10X 10Y.Quote:
class Hero
{
public bool CastingLuckytime;// = false
public Dictionary<int, Hero> or List<Hero> LuckyTimeLeechers;
}
You are over complicating thingsQuote:
int base_X = 10, base_Y = 10; int lowerX= base_X - 3, lowerY= base_Y - 3;// Lowest possible coordinate value. for (int x = lowerX; i < lowerX + 6; x++)//Enumerate through all possible X values. { for (int y = lowerY; j < lowerY + 6; y++)//Enumerating through all possible Y values. { map.SetBlessedTile(x, y); } }
That ^ is a waste of time and resources.
You are over complicating things here...
That's what i get for helping idiots... What a waste of time.Quote:
public bool BlessedTile(ushort x, ushort y)
{
return (Tile[x,y].Flags & TileFlags.Blessed) == TileFlags.Blessed;
}
Idiots? This is a very good way to handle luckytime, which uses less time/resources than enumerating through clients within the screen.Quote:
If you don't understand why looping once to set the flag and then checking for the flag (which you should be doing anyway) is better than looping and doing a distance check every single time an entity moves, then I guess there's no helping you.Quote:
He was showing you how to set it up, not the check.Quote:
public bool BlessedTile(ushort x, ushort y)
{
return (Tile[x,y].Flags & TileFlags.Blessed) == TileFlags.Blessed;
}
He was under the impression that I would be looping for a simple check. I was correcting him and telling him why he was wrong.Quote:
@Fang : Yes, I do realize that, but you can`t do it without comparisions anyways, and you can simplify most of them with bit operations as well (something like a Karnaugh map - actually not but that`s the closest example I could come up with right now).
This would work fine if you do it correctly like:Quote:
public bool BlessedTile(ushort x, ushort y)
{
return (Tile[x,y].Flags & TileFlags.Blessed) == TileFlags.Blessed;
}
On removal of the flag you can just do a check to see if the flag should remain or not, problem solved.Quote:
A B and C.
A casts luckytime, sets the tile flags to "StartPraying" or whatever, player B jumps in, Tilecheck returns StartPraying, so he does. Now C jumps in and activates luckytime, wich again sets the flag "StartPraying" but this time, C also jumps out of the screen imediatelly. Now, since Flags are static, the tiles will not have the flag "StartPraying" and once a new player (D) jumps into the screen, he wont be able to receive luckytime.
I have it checking every 1500 ms if a player is standing on a blessed tile.Quote:
When one uses lucky time you do a circle around him and put the flag Blessed.
When one moves around or just stands, check every 5 seconds (or less) if one is standing on a blessed tile.
That way you do not waste resources. You don't have to check the area around you, just the tile you are sitting on.
Even like this there is still an issue. Collisions. If two players are close to each other and both use lucky time, when one leaves, you will have to mark the area not blessed which might cut from the other's blessed area. In this case you'll have to go through your screen's players and remake all the tiles.
Is exactly what I'm doing.Quote:
Checking a collection that will hardly contain 10 references every X ms removing any reference that is > X distance and removing its pray status flag. awarding all whats left in that collection with whatever you like. updating the luckytime onscreen timer for each reference. all at the same time.Quote:
And regarding the collision:
Is exactly what I'm doing.
Sure, you'd only enumerate about 10 entities within the collection probably. And then do whatever needs be with each entry. But still, what is faster? Enumerating through a collection of the prayer, or doing ONE IF CHECK on a single tile in a timed manner. Plz.Quote:
Checking a collection that will hardly contain 10 references every X ms removing any reference that is > X distance and removing its pray status flag. awarding all whats left in that collection with whatever you like. updating the luckytime onscreen timer for each reference. all at the same time.
Bad stuff yeah?