def test_outer_circle(self):
impacts = list(
logic.tt_power_impacts(person_inner_circle=False,
place_inner_circle=False,
actor_type=self.actor_type,
actor_id=self.actor_id,
person=self.person,
amount=self.amount,
fame=self.fame))
self.assertCountEqual(impacts, [
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.OUTER_CIRCLE,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PERSON,
target_id=self.person.id,
amount=self.expected_power),
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.OUTER_CIRCLE,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PLACE,
target_id=self.person.place.id,
amount=self.expected_power),
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.FAME,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PLACE,
target_id=self.person.place.id,
amount=self.fame * self.person.attrs.places_help_amount)
])
def test_inner_circle(self):
impacts = list(logic.tt_power_impacts(inner_circle=True,
actor_type=self.actor_type,
actor_id=self.actor_id,
place=self.place_1,
amount=self.amount,
fame=self.fame))
self.assertCountEqual(impacts,
[tt_api_impacts.PowerImpact(type=tt_api_impacts.IMPACT_TYPE.INNER_CIRCLE,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PLACE,
target_id=self.place_1.id,
amount=self.expected_power),
tt_api_impacts.PowerImpact(type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.JOB_PLACE_POSITIVE,
target_id=self.place_1.id,
amount=self.expected_power),
tt_api_impacts.PowerImpact(type=tt_api_impacts.IMPACT_TYPE.FAME,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PLACE,
target_id=self.place_1.id,
amount=self.fame)])
def update_job(job, actor_id):
power = job.load_power(actor_id)
if not job.is_completed(power):
return ()
inner_circle = job.load_inner_circle(actor_id)
job_effect = job.get_apply_effect_method(power)
effect_kwargs = {
'actor_type': 'place',
'actor_name': job.get_project_name(actor_id),
'positive_heroes': inner_circle.positive_heroes,
'negative_heroes': inner_circle.negative_heroes,
'job_power': job.get_job_power(actor_id)
}
effect_kwargs.update(job.get_objects(actor_id))
after_update_operations = job_effect(**effect_kwargs)
effects_priorities = dict(job.get_effects_priorities(actor_id))
if job.effect in effects_priorities:
del effects_priorities[job.effect]
new_effect = utils_logic.random_value_by_priority(
effects_priorities.items())
if power.positive > power.negative:
impact = tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=job.ACTOR_TYPE,
actor_id=actor_id,
target_type=job.POSITIVE_TARGET_TYPE,
target_id=actor_id,
amount=-power.positive)
else:
impact = tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=job.ACTOR_TYPE,
actor_id=actor_id,
target_type=job.NEGATIVE_TARGET_TYPE,
target_id=actor_id,
amount=-power.negative)
politic_power_logic.add_power_impacts([impact])
job.name = create_name(job.ACTOR, new_effect)
job.created_at_turn = turn.number()
job.effect = new_effect
job.power_required = job.NORMAL_POWER * new_effect.power_modifier
return after_update_operations
def test_has_building(self):
places_logic.create_building(
self.person, utg_name=names.generator().get_test_name())
impacts = list(
logic.tt_power_impacts(person_inner_circle=True,
place_inner_circle=True,
actor_type=self.actor_type,
actor_id=self.actor_id,
person=self.person,
amount=self.amount,
fame=self.fame))
multiplier = (1 + c.BUILDING_PERSON_POWER_BONUS * 0.75)
expected_power = round(self.person.place.attrs.freedom * self.amount *
multiplier)
self.assertCountEqual(impacts, [
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.INNER_CIRCLE,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PERSON,
target_id=self.person.id,
amount=expected_power),
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.JOB_PERSON_POSITIVE,
target_id=self.person.id,
amount=expected_power),
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.JOB_PLACE_POSITIVE,
target_id=self.person.place.id,
amount=expected_power),
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.INNER_CIRCLE,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PLACE,
target_id=self.person.place.id,
amount=expected_power),
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.FAME,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PLACE,
target_id=self.person.place.id,
amount=self.fame * self.person.attrs.places_help_amount)
])
def setUp(self):
super().setUp()
tt_api_impacts.debug_clear_service()
impacts = []
self.hero_id = 111
self.person_id = 666
self.place_id = 777
impacts = [
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=tt_api_impacts.OBJECT_TYPE.HERO,
actor_id=self.hero_id,
target_type=tt_api_impacts.OBJECT_TYPE.JOB_PERSON_POSITIVE,
target_id=self.person_id,
amount=1000),
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=tt_api_impacts.OBJECT_TYPE.HERO,
actor_id=self.hero_id,
target_type=tt_api_impacts.OBJECT_TYPE.JOB_PERSON_NEGATIVE,
target_id=self.person_id,
amount=2000),
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=tt_api_impacts.OBJECT_TYPE.HERO,
actor_id=self.hero_id,
target_type=tt_api_impacts.OBJECT_TYPE.JOB_PLACE_POSITIVE,
target_id=self.place_id,
amount=3000),
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=tt_api_impacts.OBJECT_TYPE.HERO,
actor_id=self.hero_id,
target_type=tt_api_impacts.OBJECT_TYPE.JOB_PLACE_NEGATIVE,
target_id=self.place_id,
amount=4000)
]
foreign_impacts = copy.deepcopy(impacts)
for impact in foreign_impacts:
impact.target_id += 1
impact.amount = random.randint(1, 10000)
logic.add_power_impacts(impacts)
logic.add_power_impacts(foreign_impacts)
def tt_power_impacts(person_inner_circle, place_inner_circle, actor_type, actor_id, person, amount, fame):
power_multiplier = 1
if person.has_building:
power_multiplier += c.BUILDING_PERSON_POWER_BONUS * person.building.logical_integrity
# this power will go to person and to place
place_power = amount * power_multiplier
# this power, only to person
person_power = round(amount * power_multiplier * person.place.attrs.freedom)
impact_type = tt_api_impacts.IMPACT_TYPE.OUTER_CIRCLE
if person_inner_circle:
impact_type = tt_api_impacts.IMPACT_TYPE.INNER_CIRCLE
yield tt_api_impacts.PowerImpact(type=impact_type,
actor_type=actor_type,
actor_id=actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PERSON,
target_id=person.id,
amount=person_power)
yield from places_logic.tt_power_impacts(inner_circle=place_inner_circle,
actor_type=actor_type,
actor_id=actor_id,
place=person.place,
amount=place_power,
fame=fame * person.attrs.places_help_amount)
if not person_inner_circle:
return
target_type = tt_api_impacts.OBJECT_TYPE.JOB_PERSON_POSITIVE
if amount < 0:
target_type = tt_api_impacts.OBJECT_TYPE.JOB_PERSON_NEGATIVE
yield tt_api_impacts.PowerImpact(type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=actor_type,
actor_id=actor_id,
target_type=target_type,
target_id=person.id,
amount=abs(person_power))
def give_power(self, impacts):
impacts_to_apply = []
for hero_id, impact in impacts:
if impact > 0:
impacts_to_apply.append(tt_api_impacts.PowerImpact(type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=tt_api_impacts.OBJECT_TYPE.HERO,
actor_id=hero_id,
target_type=self.job.POSITIVE_TARGET_TYPE,
target_id=self.place_1.id,
amount=impact))
else:
impacts_to_apply.append(tt_api_impacts.PowerImpact(type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=tt_api_impacts.OBJECT_TYPE.HERO,
actor_id=hero_id,
target_type=self.job.NEGATIVE_TARGET_TYPE,
target_id=self.place_1.id,
amount=-impact))
politic_power_logic.add_power_impacts(impacts_to_apply)
def test_amount_below_zero(self):
impacts = list(
logic.tt_power_impacts(person_inner_circle=True,
place_inner_circle=True,
actor_type=self.actor_type,
actor_id=self.actor_id,
person=self.person,
amount=-self.amount,
fame=0))
self.assertCountEqual(impacts, [
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.INNER_CIRCLE,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PERSON,
target_id=self.person.id,
amount=-self.expected_power),
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.JOB_PERSON_NEGATIVE,
target_id=self.person.id,
amount=abs(self.expected_power)),
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.JOB_PLACE_NEGATIVE,
target_id=self.person.place.id,
amount=abs(self.expected_power)),
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.INNER_CIRCLE,
actor_type=self.actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PLACE,
target_id=self.person.place.id,
amount=-self.expected_power)
])
def prepair_filter_data(self):
impacts = []
for impact_type in (tt_api_impacts.IMPACT_TYPE.INNER_CIRCLE, tt_api_impacts.IMPACT_TYPE.OUTER_CIRCLE):
for account_id in (self.account_1_id, self.account_2_id):
for person_id in (self.person_1.id, self.person_2.id):
impacts.append(tt_api_impacts.PowerImpact.hero_2_person(type=impact_type,
hero_id=account_id,
person_id=person_id,
amount=random.randint(1000000, 10000000)))
impacts.append(tt_api_impacts.PowerImpact(type=impact_type,
actor_type=tt_api_impacts.OBJECT_TYPE.ACCOUNT,
actor_id=account_id,
target_type=tt_api_impacts.OBJECT_TYPE.PERSON,
target_id=person_id,
amount=random.randint(1000000, 10000000),
turn=None,
transaction=None))
for place_id in (self.place_1.id, self.place_2.id):
impacts.append(tt_api_impacts.PowerImpact.hero_2_place(type=impact_type,
hero_id=account_id,
place_id=place_id,
amount=random.randint(1000000, 10000000)))
impacts.append(tt_api_impacts.PowerImpact(type=impact_type,
actor_type=tt_api_impacts.OBJECT_TYPE.ACCOUNT,
actor_id=account_id,
target_type=tt_api_impacts.OBJECT_TYPE.PLACE,
target_id=place_id,
amount=random.randint(1000000, 10000000),
turn=None,
transaction=None))
for impact in impacts:
logic.add_power_impacts([impact])
return impacts
def tt_power_impacts(inner_circle, actor_type, actor_id, place, amount, fame):
amount = round(amount * place.attrs.freedom)
impact_type = tt_api_impacts.IMPACT_TYPE.OUTER_CIRCLE
if inner_circle:
impact_type = tt_api_impacts.IMPACT_TYPE.INNER_CIRCLE
yield tt_api_impacts.PowerImpact(
type=impact_type,
actor_type=actor_type,
actor_id=actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PLACE,
target_id=place.id,
amount=amount)
if actor_type.is_HERO and 0 < fame:
yield tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.FAME,
actor_type=actor_type,
actor_id=actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PLACE,
target_id=place.id,
amount=fame)
if not inner_circle:
return
target_type = tt_api_impacts.OBJECT_TYPE.JOB_PLACE_POSITIVE
if amount < 0:
target_type = tt_api_impacts.OBJECT_TYPE.JOB_PLACE_NEGATIVE
yield tt_api_impacts.PowerImpact(type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=actor_type,
actor_id=actor_id,
target_type=target_type,
target_id=place.id,
amount=abs(amount))
def test_fame_only_for_hero(self):
actor_type = tt_api_impacts.OBJECT_TYPE.random(exclude=(tt_api_impacts.OBJECT_TYPE.HERO,))
impacts = list(logic.tt_power_impacts(inner_circle=True,
actor_type=actor_type,
actor_id=self.actor_id,
place=self.place_1,
amount=self.amount,
fame=self.fame))
self.assertCountEqual(impacts,
[tt_api_impacts.PowerImpact(type=tt_api_impacts.IMPACT_TYPE.INNER_CIRCLE,
actor_type=actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.PLACE,
target_id=self.place_1.id,
amount=self.expected_power),
tt_api_impacts.PowerImpact(type=tt_api_impacts.IMPACT_TYPE.JOB,
actor_type=actor_type,
actor_id=self.actor_id,
target_type=tt_api_impacts.OBJECT_TYPE.JOB_PLACE_POSITIVE,
target_id=self.place_1.id,
amount=self.expected_power)])
def add_fame(hero_id, fames):
impacts = []
for place_id, fame in fames:
impacts.append(
tt_api_impacts.PowerImpact(
type=tt_api_impacts.IMPACT_TYPE.FAME,
actor_type=tt_api_impacts.OBJECT_TYPE.HERO,
actor_id=hero_id,
target_type=tt_api_impacts.OBJECT_TYPE.PLACE,
target_id=place_id,
amount=fame))
politic_power_logic.add_power_impacts(impacts)
def test_apply_effects(self):
hero_id = self.accounts_factory.create_account().id
politic_power_logic.add_power_impacts([tt_api_impacts.PowerImpact(type=tt_api_impacts.IMPACT_TYPE.INNER_CIRCLE,
actor_type=tt_api_impacts.OBJECT_TYPE.HERO,
actor_id=hero_id,
target_type=tt_api_impacts.OBJECT_TYPE.PLACE,
target_id=self.place_1.id,
amount=1)])
self.give_power([(hero_id, self.job.power_required)])
operations = logic.update_job(self.job, self.place_1.id)
self.assertTrue(operations)
for operation in operations:
operation()
