def do_skill(self, skill_type):
try:
skill = self.to_do_skill[skill_type]
except KeyError:
logging.warning('skill_type:%s does not exist' % skill_type)
return
if len(self.skills.queues) > 0: # one queue for everyone?
self.engine.log.message(message=_('You can\'t learn two things at the same time'))
return
if not self.profile.has_enough('cash', skill.cost):
self.engine.log.message(message=_('Not enough cash'))
return
self.skills.queue = json.dumps(
{skill.name: str(datetime.datetime.now() + datetime.timedelta(minutes=skill.time))[:19]})
self.skills.save()
self.profile.cash -= skill.cost
self.profile.has_skills = True
self.profile.save()
logging.debug('%s: learning %s skill at lvl %s' % (self.user, skill.name, skill.level))
self.engine.stream.trigger('skill_learn_start')
self.engine.stream.trigger('skill_%d_learn_start' % int(skill.id))
self.engine.log.message(message=_('Learning right now, come back later.'))
return True
def _unit_build(self):
qualify_tasks = query(
"SELECT user_id, city_id FROM city_unit_progress WHERE next_at<=NOW() + INTERVAL 1 MINUTE AND unit!=''")
for task in qualify_tasks.fetchall():
engine = Engine(DummyRequest(task[0]))
engine.city.id = task[1]
engine.city.set_action_type('unit')
for unit in engine.city.city_unit_progress.units:
if unit[1] > int(time.time()): continue
engine.city.city_unit.add_unit(unit[0])
engine.stream.post('unit_hired', '%s|<a href="%s">%s</a>' % (
engine.city.all_unit[str(unit[0])].name, reverse('city_enter', args=[task[1]]),
engine.city.city_map.name))
logging.debug('%s unit hired' % engine.user.user)
new_list = [x for x in engine.city.city_unit_progress.units if x[1] > int(time.time())]
engine.city.city_unit_progress.unit = json.dumps(new_list)
if len(new_list) > 0:
engine.city.city_unit_progress.next_at = datetime.datetime.fromtimestamp(min([x[1] for x in new_list]))
engine.city.city_unit_progress.save()
else:
engine.city.city_unit_progress.delete()
def add_unit(self, id, cnt=1):
units = self.units
try:
units[str(id)] += cnt
except KeyError:
units[str(id)] = cnt
self.unit = json.dumps(units)
self.save()
logging.debug('add_unit id:%s, city:%s, user:%s' % (id, self.city_id, self.user))
return True
def activate(self, profile, bonus=None):
if bonus is None:
bonus = Bonus.objects.get_by_name(self.bonus_name)
logging.debug("%s: activating %s" % (str(self.user), str(bonus.name)))
self.start_at = datetime.datetime.now()
self.end_at = datetime.datetime.now() + datetime.timedelta(hours=int(bonus.period))
self.is_active = True
self.save()
profile.__dict__["%s_mod" % self.bonus_subject] = str(bonus.mod)
profile.save()
def send_to(self, sender, receiver, msg):
try:
user = User.objects.get(username__iexact=receiver)
return self._send_to_user(sender, user, msg)
except User.DoesNotExist:
try:
gang = Gang.objects.get_by_name(name=receiver)
return self._send_to_gang(sender, gang, msg)
except Gang.DoesNotExist:
pass
logging.debug('No msg receiver %s' % receiver)
return False
def start(self):
for user in self.qualify_users:
stats = json.loads(user[1])
if not stats.has_key('robbery_done') or \
stats['robbery_done'] < 10:
logging.debug('%d not qualify for free credit' % user[0])
continue
engine = Engine(DummyRequest(user[0]))
engine.user.profile.credit += 1
engine.user.profile.save()
engine.stream.post('credit_awarded', 1)
logging.debug('%d awarded with free credit' % user[0])
def enter_city(self, cid):
self.engine.user.profile.active_city_id = cid
self.engine.user.profile.save()
city = CityMap.objects.get_by_id(cid)
if city.owner_id != self.engine.user.profile.user_id:
self.engine.stream.post_to_city_wall('city_visit', '<a href="%s">%s</a>' % (
reverse('city_enter', args=[self.engine.user.profile.default_city_id]), self.engine.user.profile.user),
city_id=cid, is_public=False)
self.in_my_city = False
logging.debug('%s entered foreign city (%s)' % (self.engine.user.user, cid))
else:
self.in_my_city = True
logging.debug('%s entered his city' % self.engine.user.user)
def block_money(self, amount):
if amount <= 0:
logging.warning("%s: tried to block <= 0 amount" % (self.engine.user.user))
self.engine.log.message(message=_("You highest offer is higher"))
return False
if self.engine.user.profile.has_enough('cash', amount):
self.engine.user.profile.cash -= amount
self.engine.user.profile.save()
logging.debug("%s: blocked $%d for auction" % (self.engine.user.user, amount))
return True
self.engine.log.message(message=_("Not enough cash"))
return False
def rem_unit(self, id, cnt=1):
units = self.units
try:
if units[str(id)] <= 0 or units[str(id)] < cnt: raise ValueError
units[str(id)] -= cnt
except (KeyError, ValueError):
logging.warning('Failed to remove unit_id:%s (city:%s, user:%s)' % (str(id), self.city_id, self.user))
return False
if units[str(id)] == 0: del units[str(id)]
self.unit = json.dumps(units)
self.save()
logging.debug('rem_unit id:%s, city:%s, user:%s' % (id, self.city_id, self.user))
return True
def recalculate_team(self, recalc_strengths=False):
"""Przelicza calkowita moc calego teamu"""
logging.debug("recalculate_team() for %s" % self.profile.user)
self.set_members()
uf = self.members
if recalc_strengths:
uf._calculate_strengths()
uf.save()
self.profile.team_attack = int(uf.attack) + int(self.profile.total_attack)
self.profile.team_defense = int(uf.defense) + int(self.profile.total_defense)
self.profile.team_respect = int(uf.respect) + int(self.profile.total_respect)
self.profile.save()
def do_job(self, user):
import math
res = {}
if self.is_premium and not user.is_premium:
res['result'] = 'NO_PREMIUM'
return res
# Job req
if not user.match_req(self.reqs):
res['result'] = 'NO_REQ'
return res
chance = get_chance(user.total_attack, \
user.total_respect, \
self.req_attack, \
self.req_respect, \
0, \
user.heat, \
user.max_heat, \
self.heat)
rand_chance = random.randint(1, 100)
if chance < rand_chance:
logging.debug("%s failed job %s" % (str(user.user), str(self.id)))
res['result'] = 'NO_CHANCE'
return res
res['result'] = True
res['cash'] = int(math.ceil(int(self.base_instant_cash) * random.uniform(0.8, 1.2)))
res['attack'] = int(self.base_attack) * random.uniform(float(self.attack_modifier_min),
float(self.attack_modifier_max))
res['defense'] = int(self.base_attack) * random.uniform(float(self.attack_modifier_min),
float(self.attack_modifier_max))
res['respect'] = int(self.base_respect) * random.uniform(float(self.respect_modifier_min),
float(self.respect_modifier_max))
res['attack'] = round(res['attack'], 2)
res['defense'] = round(res['defense'], 2)
res['respect'] = round(res['respect'], 2)
res['loot'] = self.draw_loot()
logging.debug("%s done job %s" % (str(user.user), str(self.id)))
return res
def _unit_move(self):
qualify_tasks = query(
"SELECT user_id, unit FROM city_move WHERE next_at<=NOW() + INTERVAL 1 MINUTE AND unit!=''")
for task in qualify_tasks.fetchall():
for group in json.loads(task[1]):
if group[3] > int(time.time()): continue
units_move = MapMove.objects.get_by_user(user_id=task[0])
units_move_group = MapMoveGroup.objects.get_by_id(group[2])
from_units = CityUnit.objects.get_by_user(city_id=group[0], user_id=task[0])
to_units = CityUnit.objects.get_by_user(city_id=group[1], user_id=task[0])
engine = Engine(DummyRequest(task[0]))
engine.city.id = group[1]
engine.city.set_action_type('unit')
try:
for unit_id, unit_cnt in units_move_group.units.iteritems():
to_units.add_unit(unit_id, unit_cnt)
from_units.rem_unit(unit_id, unit_cnt)
engine.stream.post('unit_moved', '%s|<a href="%s">%s</a>' % (
engine.city.UNIT[engine.city.all_unit[str(unit_id)].name],
reverse('city_enter', args=[group[1]]), engine.city.city_map.name))
logging.debug('%s unit moved' % engine.user.user)
units_move_group.delete()
new_list = [x for x in units_move.units if x[3] > int(time.time())]
units_move.unit = json.dumps(new_list)
if len(new_list) > 0:
units_move.next_at = datetime.datetime.fromtimestamp(min([x[3] for x in new_list]))
units_move.save()
else:
try:
units_move.delete()
except AssertionError:
continue
except AttributeError:
logging.error(
'Problem with moving units. %s, %s. AttErr' % (str(units_move), str(units_move_group)))
def draw_loot(self):
rand_chance = random.randint(1, 100)
loot_arr = []
last_loot = 0
for item_id, chance in self.loots.iteritems():
for i in xrange(last_loot, last_loot + int(chance)):
loot_arr.append(int(item_id))
last_loot += 1
if last_loot == 0: return
if len(loot_arr) < rand_chance: return
try:
won = loot_arr[rand_chance]
except IndexError:
return
logging.debug("won loot %s" % won)
return won
def recalculate_total(self):
"""Przelicza calkowita moc wlasnych ludzi"""
logging.debug("recalculate_total() for %s" % self.profile.user)
totals = [int(self.profile.base_attack), int(self.profile.base_defense), int(self.profile.base_respect)]
# myself + inventory
if not hasattr(self.engine, 'item'):
self.engine.register('item')
self.engine.item.set_item_type('item')
items_list = []
[items_list.extend(x) for x in self.engine.item.active_inventory.itervalues()]
for item in items_list:
totals[0] += item.attack
totals[1] += item.defense
totals[2] += item.respect
# garage
self.engine.item.set_item_type('vehicle')
for car in self.engine.item.garage[:int(self.engine.user.profile.max_cars)]:
totals[2] += car.respect
# minus
self.profile.team_attack -= self.profile.total_attack
self.profile.team_defense -= self.profile.total_defense
self.profile.team_respect -= self.profile.total_respect
# new values
self.profile.total_attack = totals[0]
self.profile.total_defense = totals[1]
self.profile.total_respect = totals[2]
self.profile.team_attack += self.profile.total_attack
self.profile.team_defense += self.profile.total_defense
self.profile.team_respect += self.profile.total_respect
# max_heat
max_should_be = int(self.profile.total_respect / 100) + 100
if self.profile.max_heat < max_should_be:
self.profile.max_heat = max_should_be
self.profile.pref_lang = self.engine.pref_lang
self.profile.save()
def add_per_day(self, source, amount, source_id=None, is_limited=None, valid_until=None):
"""Dodaje wpis do tabeli z dziennymi zarobkami/wydatkami"""
pay = UserPerDay()
pay.user = self.user
pay.source = source
if source_id is not None:
pay.source_id = source_id
pay.amount = amount
if is_limited is not None:
pay.is_limited = is_limited
if valid_until is not None:
pay.valid_until = valid_until
pay.save()
logging.debug(
"%s: pay-per-day added from source: %s(id:%s) with amount: %s"
% (pay.user, pay.source, pay.source_id, pay.amount)
)
def deactivate(self):
user_id = str(self.user.id)
subject = str(self.bonus_subject)
logging.debug("%s: deactivating %s" % (user_id, subject))
profile = UserProfile.objects.get_by_id(self.user.id)
profile.__dict__["%s_mod" % self.bonus_subject] = "1.0"
profile.save()
# archive bonus
# from django.db import connection
# sql = """INSERT INTO archive.crims_user_bonus_archive VALUES ('%s', '%s', '%s', '%s', '%s', '%s')""" % (str(self.user.id), str(self.bonus_subject), str(self.bonus_name), str(self.start_at), str(self.end_at), str(datetime.datetime.now())[:19])
# cursor = connection.cursor()
# cursor.execute(sql)
# remove
self.delete()
# any bonuses left?
user_bonuses = UserBonus.objects.get_by_user(user_id=user_id)
if user_bonuses.has_key(subject) and len(user_bonuses[subject]) > 0:
user_bonuses[subject][0].activate(profile)
def calc_tribute(self):
tribute_groups = {}
for job in JobTribute.objects.all():
if not tribute_groups.has_key(job.type): tribute_groups[job.type] = []
tribute_groups[job.type].append(int(job.id))
logging.debug("%s tributes being recalculated" % (str(self.profile.user)))
user_tribute_groups = {}
for group_type, group_items in tribute_groups.iteritems():
user_tribute_groups[group_type] = {}
user_tribute_groups[group_type]['todo'] = []
user_tribute_groups[group_type]['done'] = []
done_group = self.city_building.items.get(group_type)
if done_group is None:
user_tribute_groups[group_type]['todo'] = group_items
continue
done = []
[done.extend(x) for x in done_group.values()]
for item in group_items:
if str(item) in done:
user_tribute_groups[group_type]['done'].append(str(item))
else:
user_tribute_groups[group_type]['todo'].append(str(item))
in_list_count = 0
in_list_notify = []
out_list_count = 0
out_list_notify = []
list_report = {}
for group_type, group_items in user_tribute_groups.iteritems():
total = len(group_items['done'])
try:
ratio = float(self.city_map.population) / (total * settings.BIZ_PER_CAPITA[group_type])
except ZeroDivisionError:
ratio = float(self.city_map.population) / (1 * settings.BIZ_PER_CAPITA[group_type])
# print '--->', group_type, '<---'
# print 'GOT:', total, group_items['done']
# print 'RATIO:', ratio, '(1 per capita',settings.BIZ_PER_CAPITA[group_type],')'
if ratio < 0.8: # remove tributes
to_out = total - int(math.floor(float(self.city_map.population) / settings.BIZ_PER_CAPITA[group_type]))
if len(group_items['done']) == 0 or to_out == 0: continue
out_list = []
for i in xrange(0, to_out):
choice = random.choice(group_items['done'])
if choice not in out_list: out_list.append(choice)
# specjalnie nie ponawiamy randoma
out_list_notify.append(self.city_building.remove(group_type, out_list))
out_list_count += len(out_list)
list_report[group_type] = -(len(out_list))
# print 'out:', out_list
elif ratio > 1.0: # add tributes
to_in = int(math.floor(float(self.city_map.population) / settings.BIZ_PER_CAPITA[group_type])) - total
in_list = []
if to_in == 0 or len(group_items['todo']) == 0: continue
if to_in >= len(tribute_groups[group_type]):
in_list = [str(x) for x in tribute_groups[group_type]]
in_list_count += len(in_list)
list_report[group_type] = len(in_list)
self.city_building.add(group_type, in_list)
continue
for i in xrange(0, to_in):
choice = str(random.choice(group_items['todo']))
if choice not in in_list: in_list.append(choice)
# specjalnie nie ponawiamy randoma
if len(group_items['done']) + len(in_list) >= len(tribute_groups[group_type]): break
self.city_building.add(group_type, in_list)
in_list_count += len(in_list)
list_report[group_type] = len(in_list)
# print 'in:', in_list
else:
continue
if in_list_count != 0: in_list_notify.append(str(self.profile.user))
return (list_report, set(in_list_notify))
def kill_units(self, how_many):
logging.debug('kill %s units' % str(how_many))
for x in xrange(0, how_many):
self.rem_unit(random.choice(self.units.keys()))
