def get_best_player_rkt(request, data):
page_id = data['page_id']
page_size = data['page_size']
start_index = (page_id - 1) * page_size
to_index = page_id * page_size
total_record = ema_player_manager.count_total_rank()
player_records = ema_player_manager.get_rank_data_list_rkt(start_index, to_index)
response_data = []
for player_record in player_records:
monster_ids = [player_record.a0, player_record.a1, player_record.a2, player_record.s0, player_record.s1, player_record.s2]
monster_info = [get_mon_info(mon_id) for mon_id in monster_ids]
response_data.append({
"username": user_manager.get_user_name(player_record.trainer),
"address": player_record.trainer,
"point": player_record.point,
"monster_info": monster_info,
"total_win": player_record.total_win,
"total_lose": player_record.total_lose,
"total_match": player_record.total_win + player_record.total_lose
})
return api_response_result(request, ResultCode.SUCCESS, {"best_players": response_data, "total_record": total_record})
def update_player(player_id, new_point, ts):
if player_id not in player_info:
player_data = ema_player_manager.get_player_rank_by_id(player_id)
if not player_data:
return
address = player_data.trainer
name = user_manager.get_user_name(address)
player_info[player_id] = {
"name": name,
"address": address,
"point": -1,
"rank": 0,
"rank_info": {},
"last_update": start_time,
}
old_point = player_info[player_id]["point"]
player_info[player_id]["point"] = new_point
if old_point >= 0:
for i in range(len(points)):
if points[i] == old_point:
pos = i
break
# pos must exist
points[pos] = new_point
else:
points.append(new_point)
pos = len(points)-1
cc = 0
for i in range(pos, len(points)-1, 1):
if points[i] <= points[i+1]:
points[i], points[i+1] = points[i+1], points[i]
cc += 1
else:
break
for i in range(pos, 0, -1):
if points[i] >= points[i-1]:
points[i], points[i-1] = points[i-1], points[i]
cc += 1
else:
break
for pid, info in player_info.items():
if (info["point"] - new_point) * (info["point"] - old_point) <= 0:
new_rank = cal_rank(points, info["point"])
new_update = max(info["last_update"], ts)
old_rank = info["rank"]
last_update = info["last_update"]
if old_rank <= 10:
info["rank_info"][old_rank] = info["rank_info"].get(old_rank, 0) + new_update - last_update
info["rank"] = new_rank
info["last_update"] = new_update
def get_my_monster(request, data):
# verify information
# if not Web3.isAddress(data["trainer_address"]):
# log.warn("send_to_address_invalid|data=%s", data)
# return api_response_result(request, ResultCode.ERROR_PARAMS, {"error_message": "invald_send_to_address"})
try:
data["trainer_address"] = data["trainer_address"].lower()
metamask_flag = data.get("metamask_flag", MetamaskFlag.DISABLE)
response_data = {
"username":
user_manager.get_user_name(data["trainer_address"]),
"total_emont":
0,
"total_eth":
0,
"total_monster":
0,
"total_monster_class":
0,
"total_monster_sold":
0,
"total_lending":
0,
"total_renting":
0,
"total_selling":
0,
"total_adventure_item":
ema_adventure_manager.count_adventure_items(
data["trainer_address"]),
"current_balance":
0,
"hatching_egg": {},
"monsters": {},
}
if metamask_flag == MetamaskFlag.DISABLE:
infura_client = get_general_infura_client()
emont_contract = infura_client.getEmontContract()
world_contract = infura_client.getWorldContract()
total_emont = emont_contract.call().balanceOf(
data['trainer_address'])
total_emont = (total_emont * 1.0) / 10**8
response_data["total_emont"] = total_emont
response_data["current_balance"] = world_contract.call(
).getTrainerBalance(data['trainer_address'])
total_eth = infura_client.getCurrentEthBalance(
data['trainer_address'])
response_data["total_eth"] = (total_eth * 1.0) / 10**18
# Egg
hatching_egg = ema_egg_manager.get_hatching_egg(
data['trainer_address'])
if hatching_egg:
response_data["hatching_egg"] = {
"egg_id": hatching_egg.egg_id,
"class_id": hatching_egg.class_id,
"hatch_time": hatching_egg.hatch_time
}
on_chain_mons = list(
ema_monster_manager.get_monster_data_by_trainer(
data['trainer_address']))
off_chain_mons = list(
ema_monster_manager.get_offchain_mons(
player_address=data['trainer_address']))
monster_data_records = on_chain_mons + off_chain_mons
response_data["total_monster"] = len(monster_data_records)
monster_class_set = set()
if response_data["total_monster"] > 0:
for monster_record in monster_data_records:
monster_id = -monster_record.id if not hasattr(
monster_record,
'monster_id') else monster_record.monster_id
name = monster_record.name
class_id = monster_record.class_id
monster_class_set.add(class_id)
exp = monster_record.exp
create_index = 0 if not hasattr(
monster_record,
'create_index') else monster_record.create_index
create_time = monster_record.create_time
base_stats = [
monster_record.b0, monster_record.b1, monster_record.b2,
monster_record.b3, monster_record.b4, monster_record.b5
]
stats, bp, level = get_stats(class_id, exp, base_stats)
monster_market = ema_market_manager.get_monster_market(
monster_id)
is_approvable = not monster_market
monster_status = EmaMonsterStatus.Normal
trading = {
"lending_price": 0,
"selling_price": 0,
"release_time": 0
}
if monster_market:
if monster_market.type == EmaMarketType.SELL:
trading["selling_price"] = float(
monster_market.price
) * MARKET_PRICE_DIVISION / 10**18
monster_status = EmaMonsterStatus.Selling
response_data["total_selling"] += 1
else:
trading["lending_price"] = float(
monster_market.price
) / MARKET_PRICE_DIVISION / 10**18
extra_data = json.loads(monster_market.extra_data)
trading["release_time"] = extra_data.get(
"release_time", 0)
if monster_market.status == EmaMarketStatus.LENT:
monster_status = EmaMonsterStatus.Renting
response_data["total_renting"] += 1
else:
monster_status = EmaMonsterStatus.Lending
response_data["total_lending"] += 1
pending_exp = ema_monster_manager.get_pending_exp(monster_id)
if pending_exp is None:
pending_exp = 0
else:
pending_exp = pending_exp.adding_exp
total_stats, total_bp, total_level = get_stats(
class_id, exp + pending_exp, base_stats)
perfect_stats, perfect_rate = get_perfection(
base_stats, class_id)
monster_data = {
"monster_id":
monster_id,
"class_id":
class_id,
"class_name":
get_class_name(class_id, data["_client_language"]),
"exp":
exp,
"pending_exp":
pending_exp,
"total_level":
total_level,
"level":
level,
"next_level_exp":
get_next_level_exp(level),
"bp":
bp,
"total_bp":
total_bp,
"battle_stats":
stats,
"total_battle_stats":
total_stats,
"create_index":
create_index,
"create_time":
create_time,
"user_defined_name":
name,
"status":
monster_status,
"egg_bonus":
0 if not hasattr(monster_record, 'egg_bonus') else
monster_record.egg_bonus,
"trading":
trading,
"approvable":
is_approvable,
"perfect_stats":
perfect_stats,
"perfect_rate":
perfect_rate
}
response_data["monsters"][monster_id] = monster_data
response_data["total_monster_class"] = len(monster_class_set)
# Lunar Event
# current_ts = get_timestamp()
# if LUNAR_19_START_TIME <= current_ts <= LUNAR_19_END_TIME:
# response_data["event_data"] = {
# "bonus_eggs_left": max(0, 888 - EtheremonDB.EmaEggDataTab.objects.filter(mother_id=0).filter(
# create_time__gte=LUNAR_19_START_TIME).filter(create_time__lte=LUNAR_19_END_TIME).count()),
# "player_purchases": max(0, EtheremonDB.EmaEggDataTab.objects.filter(mother_id=0).filter(
# trainer=data["trainer_address"]).filter(create_time__gte=LUNAR_19_START_TIME).filter(
# create_time__lte=LUNAR_19_END_TIME).count())
# }
return api_response_result(request, ResultCode.SUCCESS, response_data)
except Exception as ex:
logging.exception("get_trainer_balance_fail|data=%s", data)
return api_response_result(request, ResultCode.ERROR_SERVER,
{"error_message": ex.message})
def start_battle(attacker_id,
attacker_address,
attacker_monster_ids,
defender_id,
defender_address,
defender_monster_ids,
battle_type,
add_mon_exp=True):
attacker_monsters = [
get_mon_info(mon_id) for mon_id in attacker_monster_ids
]
defender_monsters = [
get_mon_info(mon_id) for mon_id in defender_monster_ids
]
# generate random number
random_factors = [
random.randint(0, MAX_RANDOM_ROUND + 2),
random.randint(0, MAX_RANDOM_ROUND + 2),
random.randint(0, MAX_RANDOM_ROUND + 2)
]
monster_data = {
"attacker_monsters": attacker_monsters,
"defender_monsters": defender_monsters,
"random_factors": random_factors
}
monster_data_str = to_json(monster_data)
result, battle_details = get_battle_details(defender_monsters,
attacker_monsters,
random_factors, True)
monster_exp_list = [(attacker_monsters[0]["monster_id"],
battle_details[0]["attacker_exp_gain"]),
(attacker_monsters[1]["monster_id"],
battle_details[1]["attacker_exp_gain"]),
(attacker_monsters[2]["monster_id"],
battle_details[2]["attacker_exp_gain"]),
(defender_monsters[0]["monster_id"],
battle_details[0]["castle_exp_gain"]),
(defender_monsters[1]["monster_id"],
battle_details[1]["castle_exp_gain"]),
(defender_monsters[2]["monster_id"],
battle_details[2]["castle_exp_gain"])]
monster_exp_list.sort()
# make db transaction to
# 1. update monster exp
# 2. add battle details
current_ts = get_timestamp()
with transaction.atomic():
# add exp
if add_mon_exp:
for (monster_id, exp_gain) in monster_exp_list:
ema_monster_manager.add_exp(monster_id, exp_gain)
# add battle record
battle_record = EtheremonDB.BattleMatchTab(
attacker_id=attacker_id,
attacker_address=attacker_address,
defender_id=defender_id,
defender_address=defender_address,
battle_type=battle_type,
monster_data=monster_data_str,
before_battle_data="",
result=result,
after_battle_data="",
status=0,
extra="",
create_time=current_ts,
update_time=current_ts)
battle_record.save()
# add exp
if add_mon_exp:
for (monster_id, exp_gain) in monster_exp_list:
ema_monster_manager.calculate_ema_monster_exp(monster_id)
return {
"battle_id":
battle_record.id,
"attacker_id":
attacker_id,
"attacker_address":
attacker_address,
"attacker_username":
user_manager.get_user_name(attacker_address),
"attacker_monsters":
attacker_monsters,
"defender_id":
defender_id,
"defender_address":
defender_address,
"defender_username":
user_manager.get_user_name_with_cache(defender_address),
"defender_monsters":
defender_monsters,
"random_factors":
random_factors,
"details":
battle_details,
"result":
result,
}
def get_data(request, data):
monster_ids = data["monster_ids"]
response_data = {}
for monster_id in monster_ids:
if monster_id > 0:
monster_data = ema_monster_manager.get_monster_data(monster_id)
else:
monster_data = ema_monster_manager.get_offchain_mon_by_id(
-monster_id)
if not monster_data:
continue
pending_exp = ema_monster_manager.get_pending_exp(monster_id)
pending_exp = 0 if pending_exp is None else pending_exp.adding_exp
pending_exp_record = get_pending_exp_claim(monster_id)
pending_exp_txn = 0 if pending_exp_record is None else pending_exp_record.exp
base_stats = [
monster_data.b0, monster_data.b1, monster_data.b2, monster_data.b3,
monster_data.b4, monster_data.b5
]
# On-chain stats
stats, bp, level = get_stats(
monster_data.class_id,
monster_data.exp,
base_stats,
)
# On-chain + Off-chain stats
total_stats, total_bp, total_level = get_stats(
monster_data.class_id,
monster_data.exp + pending_exp,
base_stats,
)
# Perfect Stats
perfect_stats, perfect_rate = get_perfection(base_stats,
monster_data.class_id)
owner = monster_data.trainer
# Market data
monster_market = ema_market_manager.get_monster_market(monster_id)
is_approvable = not monster_market
monster_status = EmaMonsterStatus.Normal
trading = {
"lending_price": 0,
"selling_price": 0,
"release_time": 0,
"borrower": "",
"borrower_name": ""
}
if monster_market:
if monster_market.type == EmaMarketType.SELL:
trading["selling_price"] = round(
float(monster_market.price) * MARKET_PRICE_DIVISION /
ETH_UNIT, 6)
monster_status = EmaMonsterStatus.Selling
else:
owner = monster_market.player
trading["lending_price"] = round(
float(monster_market.price) * MARKET_PRICE_DIVISION /
ETH_UNIT, 6)
extra_data = json.loads(monster_market.extra_data)
trading["release_time"] = extra_data.get("release_time", 0)
trading["borrower"] = extra_data.get("borrower", "")
trading["borrower_name"] = user_manager.get_user_name(
trading["borrower"])
if monster_market.status == EmaMarketStatus.LENT:
monster_status = EmaMonsterStatus.Renting
else:
monster_status = EmaMonsterStatus.Lending
mon_history = ema_market_manager.get_trading_history(monster_id)
trading_history = []
for e in mon_history:
if e.is_sold == 1:
trading_history.append({
"class_id":
e.class_id,
"seller":
e.seller,
"seller_name":
user_manager.get_user_name(e.seller),
"buyer":
e.buyer,
"buyer_name":
user_manager.get_user_name(e.buyer),
"price":
round(
float(e.price) * MARKET_PRICE_DIVISION / ETH_UNIT, 8),
"timestamp":
e.buy_time,
"txn":
e.txn_hash
})
type_data = _MONSTER_CLASS_STATS.get(
monster_data.class_id).get("types") if _MONSTER_CLASS_STATS.get(
monster_data.class_id) is not None else 0
types = []
monster_dat = en.i18n.I18N['en']
for ty_data in type_data:
types.append(monster_dat.get("monster.type." + str(ty_data)))
response_data[monster_id] = {
"monster_id":
monster_id,
"class_id":
monster_data.class_id,
"name":
monster_data.name,
"owner":
owner,
"owner_name":
user_manager.get_user_name(owner),
"exp":
monster_data.exp,
"pending_exp":
pending_exp,
"pending_exp_txn":
pending_exp_txn,
"description":
Description.get("monster.desc." + str(monster_data.class_id)),
"types":
types,
"trading_history":
trading_history,
"level":
level,
"total_level":
total_level,
"next_level_exp":
get_next_level_exp(level),
"bp":
bp,
"total_bp":
total_bp,
"battle_stats":
stats,
"total_battle_stats":
total_stats,
"status":
monster_status,
"trading":
trading,
"egg_bonus":
0 if not hasattr(monster_data, 'egg_bonus') else
monster_data.egg_bonus,
"create_index":
0 if not hasattr(monster_data, 'create_index') else
monster_data.create_index,
"create_time":
monster_data.create_time,
"perfect_stats":
perfect_stats,
"perfect_rate":
perfect_rate,
"burn_reward":
burn_manager.get_reward_from_level(level, monster_data.class_id),
# public api
"class_name":
get_class_name(monster_data.class_id, data["_client_language"]),
"user_defined_name":
monster_data.name,
"image":
get_class_image_url(monster_data.class_id),
"3d_model":
get_gltf(monster_data.class_id),
"approvable":
is_approvable
}
return api_response_result(request, ResultCode.SUCCESS, response_data)
def get_metadata(request, data):
monster_ids = data["monster_ids"]
response_data = {}
for monster_id in monster_ids:
if monster_id > 0:
monster_data = ema_monster_manager.get_monster_data(monster_id)
else:
monster_data = ema_monster_manager.get_offchain_mon_by_id(
-monster_id)
if monster_id > 0:
monster_dcl_data = ema_monster_manager.get_monster_dcl_data(
monster_id)
if not monster_data:
continue
pending_exp = ema_monster_manager.get_pending_exp(monster_id)
pending_exp = 0 if pending_exp is None else pending_exp.adding_exp
pending_exp_record = get_pending_exp_claim(monster_id)
pending_exp_txn = 0 if pending_exp_record is None else pending_exp_record.exp
base_stats = [
monster_data.b0, monster_data.b1, monster_data.b2, monster_data.b3,
monster_data.b4, monster_data.b5
]
# On-chain stats
stats, bp, level = get_stats(
monster_data.class_id,
monster_data.exp,
base_stats,
)
if monster_dcl_data is not None:
dcl_level = get_level(monster_dcl_data.dxp)
else:
dcl_level = 0
# On-chain + Off-chain stats
total_stats, total_bp, total_level = get_stats(
monster_data.class_id,
monster_data.exp + pending_exp,
base_stats,
)
# Perfect Stats
perfect_stats, perfect_rate = get_perfection(base_stats,
monster_data.class_id)
owner = monster_data.trainer
# Market data
monster_market = ema_market_manager.get_monster_market(monster_id)
is_approvable = not monster_market
monster_status = EmaMonsterStatus.Normal
trading = {
"lending_price": 0,
"selling_price": 0,
"release_time": 0,
"borrower": "",
"borrower_name": ""
}
if monster_market:
if monster_market.type == EmaMarketType.SELL:
trading["selling_price"] = round(
float(monster_market.price) * MARKET_PRICE_DIVISION /
ETH_UNIT, 6)
monster_status = EmaMonsterStatus.Selling
else:
owner = monster_market.player
trading["lending_price"] = round(
float(monster_market.price) * MARKET_PRICE_DIVISION /
ETH_UNIT, 6)
extra_data = json.loads(monster_market.extra_data)
trading["release_time"] = extra_data.get("release_time", 0)
trading["borrower"] = extra_data.get("borrower", "")
trading["borrower_name"] = user_manager.get_user_name(
trading["borrower"])
if monster_market.status == EmaMarketStatus.LENT:
monster_status = EmaMonsterStatus.Renting
else:
monster_status = EmaMonsterStatus.Lending
mon_history = ema_market_manager.get_trading_history(monster_id)
trading_history = []
for e in mon_history:
if e.is_sold == 1:
trading_history.append({
"class_id":
e.class_id,
"seller":
e.seller,
"seller_name":
user_manager.get_user_name(e.seller),
"buyer":
e.buyer,
"buyer_name":
user_manager.get_user_name(e.buyer),
"price":
round(
float(e.price) * MARKET_PRICE_DIVISION / ETH_UNIT, 8),
"timestamp":
e.buy_time,
"txn":
e.txn_hash
})
create_index = 0 if not hasattr(
monster_data, 'create_index') else monster_data.create_index
if int(create_index) == 1:
create_index_value = "Gold"
elif int(create_index) == 2:
create_index_value = "Silver"
elif int(create_index) == 3:
create_index_value = "Bronze"
else:
create_index_value = "-"
traits = [{
"trait_type":
"Class Name",
"value":
get_class_name(monster_data.class_id, data["_client_language"])
}, {
"trait_type": "Badge",
"value": create_index_value
}, {
"trait_type":
"Mon_Artist",
"value":
credit_data.get(monster_data.class_id).get("credit")
if credit_data.get(monster_data.class_id) is not None else None
}, {
"trait_type": "OnChain_EXP",
"value": monster_data.exp
}, {
"trait_type": "Offchain_EXP",
"value": pending_exp
}, {
"trait_type": "OnChain_Level",
"value": level
}, {
"trait_type": "OffChain_Level",
"value": total_level
}, {
"trait_type": "OffChain_BP",
"value": total_bp
}, {
"trait_type": "OnChain_BP",
"value": bp
}, {
"trait_type": "Hit Point HP",
"value": total_stats[0]
}, {
"trait_type": "Primary ATK",
"value": total_stats[1]
}, {
"trait_type": "Primary DEF",
"value": total_stats[2]
}, {
"trait_type": "Secondary ATK",
"value": total_stats[3]
}, {
"trait_type": "Secondary DEF",
"value": total_stats[4]
}, {
"trait_type": "Speed SPD",
"value": total_stats[5]
}, {
"trait_type": "DCL level",
"value": dcl_level
}, {
"trait_type":
"DXP",
"value":
monster_dcl_data.dxp if monster_dcl_data is not None else 0
}, {
"display_type":
"number",
"trait_type":
"Catch_Number",
"value":
0 if not hasattr(monster_data, 'create_index') else
monster_data.create_index
}, {
"display_type":
"boost_number",
"trait_type":
"Egg_Bonus",
"value":
0 if not hasattr(monster_data, 'egg_bonus') else
monster_data.egg_bonus
}, {
"display_type": "boost_percentage",
"trait_type": "Perfection",
"value": perfect_rate
}]
response_data = {
"name":
monster_data.name,
"image":
get_class_image_url(monster_data.class_id),
"external_url":
"https://ethermon.io/mons-info/" + str(monster_id),
"description":
Description.get("monster.desc." + str(monster_data.class_id)),
"attributes":
traits,
#"monster_id": monster_id,
#"class_id": monster_data.class_id,
#"owner": owner,
#"owner_name": user_manager.get_user_name(owner),
#"create_time": monster_data.create_time,
#"user_defined_name": monster_data.name,
#"approvable": is_approvable
#"exp": monster_data.exp,
#"pending_exp": pending_exp,
#notused"pending_exp_txn": pending_exp_txn,
#notused"trading_history": trading_history,
#"level": level,
#"total_level": total_level,
#notused"next_level_exp": get_next_level_exp(level),
#"bp": bp,
#"total_bp": total_bp,
#notused"battle_stats": stats,
#"total_battle_stats": total_stats,
#notused"status": monster_status,
#notused"trading": trading,
#"egg_bonus": 0 if not hasattr(monster_data, 'egg_bonus') else monster_data.egg_bonus,
#"create_index": 0 if not hasattr(monster_data, 'create_index') else monster_data.create_index,
#notused"perfect_stats": perfect_stats,
#"perfect_rate": perfect_rate,
#notused"burn_reward": burn_manager.get_reward_from_level(level, monster_data.class_id),
# public api
#"class_name": get_class_name(monster_data.class_id, data["_client_language"]),
#"user_defined_name": monster_data.name,
#notused"3d_model": get_gltf(monster_data.class_id),
#"approvable": is_approvable
}
return api_response_result(request, ResultCode.SUCCESS, response_data)