You could store, for each user, a date when they last received new turns. If they try to use a turn when they don't have one, check the date. If they're due to get new turns, add them to the turn count and update the date.

You could also store the dates of all of the user's last turns taken. When the user tries to use a turn, delete all the records that are over a day old. If there are still too many turns used, disallow the turn. This gives a slightly different turn allowance, though. It's not x turns every day but x turns in any day-long period.

Update to expand on that second idea a bit (since roboticus likes it): I recall years ago a couple of friends in a turn-based game would make a killing by waiting until the end of the "day" to take all their turns, then wait for the new turns to arrive shortly after, and take all their turns again. By doing this, they could double their effect in a short time. A "turns in time period" approach would defeat that strategy. I don't know anything about Spidey's game, so it may be the case that this "last minute, first minute" approach doesn't really gain the player any advantage.

The down side comes for a user who tries to play at the same time every day. Let's say the player arrives at noon, takes all turns, and returns the next day. The player has to wait for a minute after noon to play again. Every day, the time when play is allowed moves later. This also means that I can't play one afternoon and then play again the next morning.

Perhaps a better solution is a mix of some kind.

The main problem I have with the first approach (all turns arrive at a fixed time every day) is that it might not work well for people in other time zones. If I were playing a game where turns arrive at noon, I'd have to play either in the morning or in the afternoon every day.

Anyway, I'm rambling a lot more than I meant to (and not even with code!).

kyle:

++ I really like your second method. If Spidy's game would benefit from frequent visits, that might make it a bit more compelling, as turns wouldn't arrive in larger/less frequent "bunches".

...roboticus

I'm not a MySQL maven, so I'm going to pretend that you said "Sybase" and leave the conversion effort as an exercise for the reader.... 8^)

First, using your basic idea, you could (on login) compute the number of turns they get for the day. (I'd put a maximum on it, so if they don't log in for a long time they don't get too many turns for a day.) It seems like an appropriate task for the database, so you could do something like this. Given tables something like:

create table users (
    user_id    varchar(10) primary key,
    ... --standard junk you already have here
    turns_left int default 0,
    last_turn  datetime default getdate()
)

create table misc (
    tag varchar(32) primary key,
    val varchar(128)
)
go
insert misc (tag, val) values ('Turns_Per_Day', '5')
insert misc (tag, val) values ('Max_Turns_Allowed', '15')
[download]

create proc compute_turns_left
    @user_id varchar(10)
as
    declare @days integer, @turns, @turns_per_day, @max_turns

    -- Read the configuration variables
    select @turns_per_day = isnull(convert(int, val), 1)
        from misc where tag='Turns_Per_Day'
    select @max_turns = isnull(convert(int, val), 1)
        from misc where tag='Max_Turns_Allowed'

    -- How many days since they last used a turn?
    select @days=datediff(d,getdate(),last_turn)
        from users where user_id=@user_id

    -- Update their turns
    update turns_left = turns_left + @days * @turns_per_day
    from users where user_id=@user_id

    -- And apply the limit cap
    update turns_left = @max_turns
        from users where user_id=@user_id and turns_left > @max_turns
go
[download]

create proc consume_turn
    @user_id varchar(10)
as
    update users set turns_left = turns_left-1, last_turn=getdate()
        where user_id=@user_id
go
[download]

...roboticus

The simplist way is from cron, or similar

  update table set turns = turns+ x;
  update table set turns = max where turns > max;
  commit;
[download]

As a next option, if you don't have people logged on for days at a time, you can just give them their turns on login -- keep track of their last login date, and when they log in, give them (turns_per_day * (datediff(systime(), last_login))).

  update table set
    last_login = sysdate(),
    turns_left = ( $turns_per_day * datediff( sysdate(), last_login ))
  where user_id = ?
[download]

update:: bah ... the second example didn't take into consideration order of operations:

  update table set
    turns_left = ( $turns_per_day * datediff( sysdate(), last_login ))
+,
    last_login = sysdate()
  where user_id = ?
[download]