Source.Python forums

import os.path
import pickle
from path import Path
from players.entity import PlayerEntity
from players.helpers import index_from_userid
from events import Event
from listeners.tick import TickRepeat


players_credit = {}
credit_repeat = {}

def load():
	global players_credit
	base_path = Path(__file__).parent
	str_path = base_path + '/player_credit.db'
	with open(str_path, 'rb') as player_credit:
		players_credit = pickle.load(player_credit)

def unload():
	save_database()
	for userid in credit_repeat:
		credit_repeat[userid].stop()
@Event		
def player_connect(game_event):
	userid = game_event.get_int('userid')
	steamid = game_event.get_string('networkid')
	if not steamid in players_credit:
		players_credit[steamid] = {}
		players_credit[steamid]['credit'] = 0
	credit_repeat[userid] = TickRepeat(giveCredits, steamid)
	credit_repeat[userid].start(60, 0)

@Event	
def player_disconnect(game_event):
	userid = game_event.get_int('userid')
	credit_repeat[userid].stop()
	save_database()	
		
def save_database():
	base_path = Path(__file__).parent
	str_path = base_path + '/player_credit.db'
	with open(str_path, 'wb') as player_credit:
		pickle.dump(players_credit, player_credit)
		
def giveCredits(steamid):
	players_credit[steamid]['credit'] += 1

str_path = Path(__file__).parent.joinpath('player_credit.db')

def load():
    global players_credit
    if not str_path.isfile():
        return
    with str_path.open('rb') as open_file:
        players_credit = pickle.load(open_file)


def save_database():
    with str_path.open('wb') as open_file:
        pickle.dump(players_credit, open_file)

from listeners.tick import TickRepeat
from listeners.tick import TickRepeatStatus
from players.entity import PlayerEntity
from players.helpers import index_from_userid


class PlayerDictionary(dict):
    def __missing__(self, userid):
        value = self[userid] = PlayerInstance(userid)
        return value

    def __delitem__(self, userid):
        if userid not in self:
            return
        self[userid].stop_repeat()
        super(PlayerDictionary, self).__delitem__(userid)

    def clear(self):
        for item in list(self):
            del self[item]

player_dictionary = PlayerDictionary()


class PlayerInstance(PlayerEntity):
    def __new__(cls, userid):
        index = index_from_userid(userid)
        self = super(PlayerInstance, cls).__new__(cls, index)
        return self

    def __init__(self, userid):
        self._repeat = TickRepeat(self.give_credits)

    @property
    def repeat(self):
        return self._repeat

    def start_repeat(self):
        if self.repeat.status is TickRepeatStatus.STOPPED:
            self.repeat.start(60, 0)

    def stop_repeat(self):
        if self.repeat.status is TickRepeatStatus.RUNNING:
            self.repeat.stop()

    def give_credits(self):
        players_credit[self.steamid]['credit'] += 1


def unload():
    player_dictionary.clear()


@Event
def player_activate(game_event):
    player_dictionary[game_event.get_int('userid')].start_repeat()


@Event
def player_disconnect(game_event):
    del player_dictionary[game_event.get_int('userid')]
    save_database()