def select(self, rand=None, rate_max=10000):
"""選別.
"""
if self.__rate_total < 1:
return None
elif rand is None or type(rand) == int:
rand = AppRandom()
v = rand.getIntN(self.__rate_total)
for data in self.__data_list:
v -= data.rate
if v < 1:
return data
return None
def select(self, rand=None):
if not self.can_select():
return None
elif rand is None:
rand = AppRandom()
table = (
(Defines.TreasureType.GOLD, self.__scoutmaster.treasuregold),
(Defines.TreasureType.SILVER, self.__scoutmaster.treasuresilver),
(Defines.TreasureType.BRONZE, self.__scoutmaster.treasurebronze),
)
v = rand.getIntN(self.__rate_total)
for treasure_type, rate in table:
if 0 < rate and v < rate:
return treasure_type
v -= rate
return None
def handle(self, *args, **options):
print '======================================='
print 'Generate cabaret club user ranking data'
print '======================================='
players = Player.fetchValues(using=settings.DB_READONLY)
rand = AppRandom()
redisdb = RedisModel.getDB()
pipe = redisdb.pipeline()
for player in players:
sales = rand.getIntN(10000)
CabaClubRanking.create("currentweek", player.id, sales).save(pipe)
CabaClubRanking.create("lastweek", player.id,
max(100, sales - 1500)).save(pipe)
pipe.execute()
print '================================'
print 'all done...'
class ScoutEventExec:
CONTINUITY_MAX = 10
def __init__(self,
player,
progressdata,
seed,
master,
nextlevelexp,
cardnum=0,
do_happening=True,
happnings=None,
is_lovetime=False,
title=None,
is_full=None):
self.ap = player.get_ap()
self.apmax = player.get_ap_max()
self.exp = player.exp
self.result = []
self.eventlist = []
self.rand = AppRandom(seed=seed)
self.happeningselector = None
self.treasureselector = None
self.is_cleared = master.stage == progressdata.cleared
if self.is_cleared and master.stage != progressdata.stage:
resultlist = progressdata.result.get('result', [])
if resultlist:
self.progress = resultlist[-1]['progress']
else:
self.progress = master.execution
else:
self.progress = progressdata.progress
self.master = master
self.nextlevelexp = nextlevelexp
self.__exec_cnt = 0
self.__progressdata = progressdata
self.__eventrate_drop = 1
self.__eventrate_happening = 0
self.__eventrate_treasure = 0
self.__eventrate_gachapt = 0
self.__eventrate_drop = master.eventrate_drop
self.__eventrate_gachapt = getattr(master, 'eventrate_gachapt', 0)
if do_happening:
if is_full:
self.__eventrate_happening = master.eventrate_happening_full
else:
self.__eventrate_happening = master.eventrate_happening
self.happeningselector = ScoutHappeningSelector(
player, master, happnings)
self.treasureselector = ScoutTreasureSelector(master)
if self.treasureselector.can_select():
if is_full:
self.__eventrate_treasure = master.eventrate_treasure_full
else:
self.__eventrate_treasure = master.eventrate_treasure
self.itemselector = ScoutDropItemSelector(player, master, cardnum)
self.__eventpointmin = getattr(master, 'eventpointmin', 0)
self.__eventpointmax = getattr(master, 'eventpointmax', 0)
self.__eventrate_lt_star = getattr(master, 'eventrate_lt_star',
0) if not is_lovetime else 0
eventrate_total = self.__eventrate_drop
eventrate_total += self.__eventrate_happening
eventrate_total += self.__eventrate_treasure
eventrate_total += self.__eventrate_gachapt
eventrate_total += self.__eventrate_lt_star
self.__eventrate_total = eventrate_total
# 称号効果.
if title:
self.__title_effect_gold = title.gold_up
self.__title_effect_exp = title.exp_up
else:
self.__title_effect_gold = 0
self.__title_effect_exp = 0
self.__player = player
@property
def is_end(self):
return 0 < len(self.eventlist)
@property
def exec_cnt(self):
return self.__exec_cnt
def end(self):
if not self.is_end:
self.addEvent(Defines.ScoutEventType.NONE)
@property
def is_levelup(self):
return self.nextlevelexp and self.nextlevelexp.exp <= self.exp
def add_exp(self, exp):
if self.nextlevelexp:
self.exp += exp
@property
def nextexp(self):
if self.nextlevelexp:
return self.nextlevelexp.exp
else:
return self.exp
def select_event(self):
"""イベント選択.
"""
if self.__eventrate_total < 1:
return None
v = self.rand.getIntN(self.__eventrate_total)
if 0 <= v < self.__eventrate_drop:
# カードかアイテムがドロップ.
data = self.itemselector.select(self.rand)
if data:
# 何か発見.
if data.itype == Defines.ItemType.CARD:
# カード獲得.
return ScoutEventGetCard.create(data.mid,
silhouette=data.silhouette,
heart=data.heart)
elif data.itype == Defines.ItemType.ITEM:
# アイテム獲得.
return ScoutEventGetItem.create(data.mid)
return None
v -= self.__eventrate_drop
if 0 <= v < self.__eventrate_gachapt:
# イベントガチャポイント.
point = self.rand.getIntS(self.master.gachaptmin,
self.master.gachaptmax)
return ScoutEventEventGacha.create(point)
v -= self.__eventrate_gachapt
if 0 <= v < self.__eventrate_happening:
# ハプニング.
happening = self.happeningselector.select(self.rand)
if happening:
return ScoutEventHappening.create(happening.mid)
return None
v -= self.__eventrate_happening
if 0 <= v < self.__eventrate_treasure:
# 宝箱発見.
treasure_type = self.treasureselector.select(self.rand)
if treasure_type is not None:
return ScoutEventGetTreasure.create(treasure_type)
return None
v -= self.__eventrate_treasure
if 0 <= v < self.__eventrate_lt_star:
# 星.
num = self.rand.getIntS(self.master.lovetime_star_min,
self.master.lovetime_star_max)
return ScoutEventLoveTimeStar.create(num)
v -= self.__eventrate_lt_star
return None
def execute(self, apcost):
if self.is_end:
raise CabaretError(u'スカウト実行:終了済み')
elif self.ap < apcost:
self.addEvent(Defines.ScoutEventType.AP_NONE, self.master.id)
self.end()
return
elif ScoutExec.CONTINUITY_MAX <= self.__exec_cnt:
# 一度強制終了.
self.end()
return
self.__exec_cnt += 1
ap_pre = self.ap
self.ap -= apcost
gold_add = int(
self.rand.getIntS(self.master.goldmin, self.master.goldmax) *
(self.__title_effect_gold + 100) / 100)
exp_add = int(self.master.exp * (self.__title_effect_exp + 100) / 100)
# 設定期間中に経験値を指定倍率に上げる.
if Defines.EXP_START_TIME <= OSAUtil.get_now() <= Defines.EXP_END_TIME:
exp_add = int(exp_add * Defines.EXP_RATE_OVER)
exp_pre = self.exp
self.add_exp(exp_add)
progress_pre = self.progress
self.progress += 1
# スカウトイベントポイント
point_add = self.rand.getIntS(self.__eventpointmin,
self.__eventpointmax)
obj = ScoutEventExec.makeResultObject(self.__player.level, exp_pre,
self.exp, exp_add, gold_add,
ap_pre, self.ap, self.apmax,
apcost, progress_pre,
self.progress,
self.master.execution, point_add)
self.result.append(obj)
# 3ポチ確認.
eventflag = (self.progress % Defines.SCOUT_EVENT_RATE) == 0
# レベルアップ.
if self.is_levelup:
self.addEvent(Defines.ScoutEventType.LEVELUP,
self.nextlevelexp.level)
# クリア判定.
if not self.is_cleared and self.master.execution <= self.progress:
self.addEvent(Defines.ScoutEventType.COMPLETE, self.master.id)
elif not self.is_end and eventflag:
event = self.select_event()
if event:
self.addEvent(event)
else:
self.end()
def addEvent(self, event, *args):
if not isinstance(event, ScoutEventData):
eventtype = event
data_cls = get_class_by_type(eventtype)
event = data_cls.create(*args)
self.eventlist.append(event)
@staticmethod
def makeResultObject(level, exp_pre, exp_post, exp_add, gold_add, ap_pre,
ap_post, ap_max, ap_cost, progress_pre, progress_post,
execution, point_add):
exp_add = exp_post - exp_pre
return {
'level': level,
'exp_pre': exp_pre,
'exp_post': exp_post,
'exp_add': exp_add,
'gold_add': gold_add,
'ap_pre': ap_pre,
'ap_post': ap_post,
'ap_max': ap_max,
'apcost': ap_cost,
'progress_pre': progress_pre,
'progress': progress_post,
'execution': execution,
'point_add': point_add,
}
def cancelEvent(self):
# これやだなぁ..
self.eventlist = []
self.end()
def aggregatePrizes(self):
exp_total = 0
gold_total = 0
point_total = 0
for result in self.result:
exp_total += result['exp_add']
gold_total += result['gold_add']
point_total += result['point_add']
prize = {
'gold': gold_total,
'exp': exp_total,
'point': point_total,
}
for event in self.eventlist:
prize[Defines.ScoutEventType.ENG_NAMES[event.get_type()]] = event
return prize
def __testGacha(self, gachamaster, cnt):
"""ガチャをテスト実行.
"""
model_mgr = self.getModelMgr()
test_playdata = GachaPlayData.makeInstance(
GachaPlayData.makeID(0, gachamaster.boxid))
# BOX.
box = GachaBox(gachamaster, test_playdata)
groupidlist = box.get_group_id_list()
groupdict = dict([
(groupmaster.id, GachaBoxGroup(groupmaster))
for groupmaster in BackendApi.get_gachagroupmaster_list(
model_mgr, groupidlist, using=backup_db)
])
# 設定値.
group_rate_dict = {}
cardrate_dict = {}
cardgroup_dict = {}
for groupid in groupidlist:
rate = box.get_group_rate(groupid)
group_rate_dict[groupid] = group_rate_dict.get(groupid, 0) + rate
group_cardrate_dict = {}
group = groupdict[groupid]
for carddata in group.carddata_list:
cardid = carddata.card
group_cardrate_dict[cardid] = group_cardrate_dict.get(
cardid, 0) + carddata.rate
arr = cardgroup_dict[cardid] = cardgroup_dict.get(cardid) or []
arr.append(groupid)
cardrate_dict[groupid] = group_cardrate_dict
# ランダム.
rand = AppRandom()
# result_list = []
distribution_dict = dict.fromkeys(cardgroup_dict.keys(), 0)
group_distribution_dict = dict.fromkeys(groupdict.keys(), 0)
def addResult(cardid, point, groupid):
# result_list.append((cardid, point, groupid))
distribution_dict[cardid] = (distribution_dict.get(cardid)
or 0) + 1
group_distribution_dict[groupid] = (
group_distribution_dict.get(groupid) or 0) + 1
# ランキングガチャ用ポイント獲得関数.
point_getter = lambda x: 0
if gachamaster.consumetype == Defines.GachaConsumeType.RANKING:
rankinggachamaster = BackendApi.get_rankinggacha_master(
model_mgr, gachamaster.boxid, using=backup_db)
if rankinggachamaster:
randmax = rankinggachamaster.randmax
randmin = rankinggachamaster.randmin
point_getter = lambda x: x.point * (100 + rand.getIntN(
randmin + randmax) - randmin) / 100
# BOXからグループを選択.
groupidlist = []
for _ in xrange(cnt):
if box.is_empty:
# 空になったのでリセット.
test_playdata.resetGroupCounts()
box = GachaBox(gachamaster, test_playdata)
groupid, _ = box.select(rand)
group = groupdict[groupid]
carddata = group.select_obj(rand)
addResult(carddata.card, point_getter(carddata), groupid)
# self.html_param['result_list'] = result_list
self.html_param['distribution_dict'] = distribution_dict
self.html_param['group_dict'] = groupdict
self.html_param['group_distribution_dict'] = group_distribution_dict
self.html_param['group_rate_dict'] = group_rate_dict
self.html_param['group_rate_total'] = sum(group_rate_dict.values())
self.html_param['cardrate_dict'] = cardrate_dict
self.html_param['cardgroup_dict'] = cardgroup_dict
cardmaster_idlist = distribution_dict.keys()
cardmaster_dict = BackendApi.get_cardmasters(cardmaster_idlist,
model_mgr,
using=backup_db)
self.html_param['cardmaster_dict'] = cardmaster_dict
