1382 lines
63 KiB
C#
1382 lines
63 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using UnityEngine;
|
|
|
|
namespace TKS.OutGame.Net
|
|
{
|
|
/// <summary>
|
|
/// 서버 모드의 아웃게임 세션.
|
|
/// 화면 코드는 그대로 둔다 — 동작(레벨업 · 장착 · 승급 · 진화 · 스킬 · 편성 · 군량 구매 · 전투 입장)은 기기에서 먼저 반영하고(기존 규칙 그대로),
|
|
/// 같은 동작을 서버에 순서대로 보낸 뒤(ServerSync) 서버의 계정 상태로 기기 값을 덮는다. 서버 규칙은 기기 규칙을 옮긴 것이라 평소엔 값이 같다.
|
|
/// **전투 종료만은 서버 응답을 기다린다** — 장비 · 상자 드랍은 서버가 정하기 때문(응답이 오면 RewardReady).
|
|
/// 4단계 = 연무장(탑 · 일일 던전 · 투기장 · 적장 토벌 · 메달 상점) · 우편 · 쿠폰 — 연무장 전투 종료도 서버 응답을 기다린다(ModeReady).
|
|
/// </summary>
|
|
public class ServerSession : OutGameSession
|
|
{
|
|
// 서버의 재화 묶음 이름(재화 표 s_wallet) → 기기 세이브 칸. 서버가 관리하기 시작한 것만 덮는다(단계가 올라가면 여기에 더한다).
|
|
const string WalletGold = "gold";
|
|
const string WalletGem = "gem"; // 유료 + 무료의 합 = 화면의 「보옥」
|
|
const string WalletSkillBook = "skill_book";
|
|
const string WalletIron = "iron";
|
|
const string WalletBlueprint = "blueprint";
|
|
const string WalletChestPoint = "chest_point";
|
|
const string WalletTowerTicket = "tower_ticket";
|
|
const string WalletMedal = "medal";
|
|
// 서버 일일 횟수의 던전 키 = 「dungeon:<던전 ID>」
|
|
const string DungeonCountPrefix = "dungeon:";
|
|
// 우편 보상 종류(서버 TKS_MAIL_REWARD)
|
|
const string RewardGoods = "goods";
|
|
const string RewardGear = "gear";
|
|
const string RewardChest = "chest";
|
|
// 서버 메시지(우편 · 공지사항) 글의 언어 칸 — 게임에 언어 설정이 생기면 그 값으로 바꾼다(서버는 ko · en · ja · zh-Hans · zh-Hant 칸을 준다)
|
|
const string MailLang = "ko";
|
|
// 우편 보상에 보여 줄 재화 이름(묶음 → 이름)
|
|
static readonly Dictionary<string, string> WalletName = new Dictionary<string, string>
|
|
{
|
|
{ WalletGold, "골드" }, { WalletGem, "보옥" }, { WalletSkillBook, "스킬서" }, { WalletIron, "운철" }, { WalletBlueprint, "도면" },
|
|
{ WalletChestPoint, "상자 포인트" }, { WalletTowerTicket, "탑 입장권" }, { WalletMedal, "메달" },
|
|
};
|
|
// 서버가 직접 세는 보물 조건 누적 — 기기가 보고하지 않는다
|
|
static readonly string[] ServerCounted = { BattleEvents.Battles, BattleEvents.GoldSpent, BattleEvents.Patrols };
|
|
|
|
public ServerSync Sync { get; private set; }
|
|
|
|
enum Entry
|
|
{
|
|
None,
|
|
Pending,
|
|
Ok,
|
|
Rejected
|
|
}
|
|
|
|
// 전투 입장권(서버가 입장 때 준 세션 ID) — 종료 때 그대로 돌려준다
|
|
Entry entry = Entry.None;
|
|
string stageSession;
|
|
// 연무장 전투 입장권(탑 · 던전 · 투기장 · 토벌) — 종료 때 그대로 돌려준다
|
|
Entry modeEntry = Entry.None;
|
|
string modeSession;
|
|
// 입장할 때의 보물 조건 누적 — 종료 때 늘어난 만큼만 서버에 알린다
|
|
readonly Dictionary<string, int> countersAtEntry = new Dictionary<string, int>();
|
|
|
|
// 재화 목록(서버 기준 정보) : 재화 ID → 묶음
|
|
readonly Dictionary<string, string> walletOf = new Dictionary<string, string>();
|
|
TimeSpan clockOffset = TimeSpan.Zero;
|
|
|
|
public ServerSession(OutGameData db, BalanceConfig cfg, SaveData save) : base(db, cfg, save)
|
|
{
|
|
Clock = () => DateTime.UtcNow + clockOffset; // 군량 회복 · 일일 초기화를 서버 시각에 맞춘다
|
|
Sync = ServerSync.Create(this);
|
|
}
|
|
|
|
static string Json(Action<JObject> fill)
|
|
{
|
|
var o = new JObject();
|
|
fill(o);
|
|
return o.ToString(Formatting.None);
|
|
}
|
|
|
|
static string Esc(string id)
|
|
{
|
|
return Uri.EscapeDataString(id ?? "");
|
|
}
|
|
|
|
// ---------- 기기 시간대 (일일 초기화 기준 = 그 나라 0시 · 서버가 가입할 때 계정에 고정한다) ----------
|
|
|
|
/// <summary>
|
|
/// 기기 시간대 — 이름과 UTC 와의 차(분). 이름이 서버가 아는 이름(IANA · 예: Asia/Seoul)이면 서버가 서머타임까지 따라가고,
|
|
/// 모르는 이름(윈도우 이름 등)이면 서버가 이름을 버리고 차(분)로 계산한다.
|
|
/// </summary>
|
|
internal static void DeviceTimezone(out string zone, out int offsetMin)
|
|
{
|
|
try
|
|
{
|
|
var tz = TimeZoneInfo.Local;
|
|
zone = tz.Id ?? "";
|
|
offsetMin = (int)Math.Round(tz.GetUtcOffset(DateTime.Now).TotalMinutes);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
zone = "";
|
|
offsetMin = (int)Math.Round((DateTime.Now - DateTime.UtcNow).TotalMinutes);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 접속할 때의 계정 조회 주소 — 기기 시간대와 접속 정보를 실어 보낸다.
|
|
/// 서버는 시간대를 계정을 만드는 순간에만 계정에 고정하고, 접속 정보는 접속 기록 · 가입 정보 · 모든 게임 로그의 앱 버전/플랫폼 칸에 쓴다.
|
|
/// </summary>
|
|
internal static string AccountPath()
|
|
{
|
|
if (ServerLink.SkipSignupTimezone) return "/tks/account?" + ClientQuery();
|
|
string zone;
|
|
int offsetMin;
|
|
DeviceTimezone(out zone, out offsetMin);
|
|
return "/tks/account?zone=" + Esc(zone) + "&offsetMin=" + offsetMin.ToString(CultureInfo.InvariantCulture) + "&" + ClientQuery();
|
|
}
|
|
|
|
// ---------- 접속 정보 (게임 로그 — 서버가 접속 기록 · 가입 정보 · 로그의 앱 버전/플랫폼 칸에 쓴다) ----------
|
|
|
|
// 서버가 받는 길이(넘으면 서버가 그 칸을 비운다)
|
|
const int PlatformMax = 12;
|
|
const int LangMax = 12;
|
|
const int DeviceMax = 80;
|
|
|
|
/// <summary>접속 정보 — 플랫폼 · 앱 버전 · 지역(ISO 두 글자) · 언어 · 기기 모델. 구하지 못한 값은 비워 보낸다(서버가 빈 값으로 둔다 · 지역이 비면 서버가 시간대로 추정한다).</summary>
|
|
public static string ClientQuery()
|
|
{
|
|
return "platform=" + Esc(PlatformName()) + "&ver=" + Esc(Application.version ?? "") + "&country=" + Esc(DeviceCountry())
|
|
+ "&lang=" + Esc(DeviceLanguage()) + "&device=" + Esc(Cut(SystemInfo.deviceModel ?? "", DeviceMax));
|
|
}
|
|
|
|
static string Cut(string s, int max)
|
|
{
|
|
return s.Length <= max ? s : s.Substring(0, max);
|
|
}
|
|
|
|
/// <summary>플랫폼 이름 — android · ios · editor · 그 밖은 Unity 의 플랫폼 이름(소문자).</summary>
|
|
static string PlatformName()
|
|
{
|
|
if (Application.isEditor) return "editor";
|
|
switch (Application.platform)
|
|
{
|
|
case RuntimePlatform.Android: return "android";
|
|
case RuntimePlatform.IPhonePlayer: return "ios";
|
|
default: return Cut(Application.platform.ToString().ToLowerInvariant(), PlatformMax);
|
|
}
|
|
}
|
|
|
|
/// <summary>기기 지역(ISO 두 글자) — 구하지 못하면 빈 값.</summary>
|
|
static string DeviceCountry()
|
|
{
|
|
try
|
|
{
|
|
var code = RegionInfo.CurrentRegion.TwoLetterISORegionName ?? "";
|
|
return code.Length == 2 && char.IsLetter(code[0]) && char.IsLetter(code[1]) ? code.ToUpperInvariant() : "";
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return "";
|
|
}
|
|
}
|
|
|
|
/// <summary>기기 언어 — 문화권의 두 글자 언어 코드(ko · en …) · 없으면 Unity 의 시스템 언어 이름.</summary>
|
|
static string DeviceLanguage()
|
|
{
|
|
try
|
|
{
|
|
var code = CultureInfo.CurrentUICulture.TwoLetterISOLanguageName ?? "";
|
|
if (code.Length == 2 && code != "iv") return code.ToLowerInvariant(); // iv = 문화권을 모르는 기기
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// 아래 값으로
|
|
}
|
|
return Cut(Application.systemLanguage.ToString(), LangMax);
|
|
}
|
|
|
|
/// <summary>진행 단계 보고(튜토리얼 …) — 서버의 단계 표에 있는 이름만 남는다. 유저마다 처음 한 번만 남으므로 여러 번 보내도 된다. 거절돼도 게임은 그대로 진행한다.</summary>
|
|
public override void ReportStep(string step)
|
|
{
|
|
if (string.IsNullOrEmpty(step)) return;
|
|
Sync.Post("POST", "/tks/funnel", () => Json(o => { o["step"] = step; }), soft: true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 시간대가 없는 계정(이 기능 전에 만든 계정)이면 기기 시간대를 한 번 보낸다 — 첫 설정은 서버가 그대로 받는다.
|
|
/// 거절돼도 게임은 그대로 진행한다(그 계정은 한국 시간으로 계산된다).
|
|
/// </summary>
|
|
void EnsureTimezone(JObject j)
|
|
{
|
|
var set = j.SelectToken("account.tz.set");
|
|
if (set == null || Flag(set)) return; // 칸이 없는 서버이거나 이미 정해진 계정
|
|
string zone;
|
|
int offsetMin;
|
|
DeviceTimezone(out zone, out offsetMin);
|
|
Sync.Post("PUT", "/tks/account/timezone", () => Json(o =>
|
|
{
|
|
o["zone"] = zone;
|
|
o["offsetMin"] = offsetMin;
|
|
}), soft: true);
|
|
}
|
|
|
|
// ---------- 서버 → 기기 ----------
|
|
|
|
/// <summary>기준 정보의 재화 목록(ID · 묶음)을 읽는다. 필요한 묶음이 없으면 false.</summary>
|
|
internal bool LoadGoodsTable(ServerResult r)
|
|
{
|
|
walletOf.Clear();
|
|
var list = r.At("goods") as JArray;
|
|
if (list == null) return false;
|
|
foreach (var g in list)
|
|
{
|
|
var id = (string)g["id"];
|
|
var wallet = (string)g["wallet"];
|
|
if (!string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(wallet)) walletOf[id] = wallet;
|
|
}
|
|
foreach (var need in new[] { WalletGold, WalletGem, WalletSkillBook, WalletIron, WalletBlueprint, WalletChestPoint, WalletTowerTicket, WalletMedal })
|
|
if (!walletOf.ContainsValue(need))
|
|
{
|
|
Debug.LogError("[TKS] 서버 재화 목록에 묶음 「" + need + "」 가 없습니다");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static int Int(JToken t)
|
|
{
|
|
if (t == null || t.Type == JTokenType.Null) return 0;
|
|
long n;
|
|
return long.TryParse(t.ToString(), NumberStyles.Integer, CultureInfo.InvariantCulture, out n) ? (int)Math.Min(int.MaxValue, Math.Max(int.MinValue, n)) : 0;
|
|
}
|
|
|
|
int WalletSum(JObject goods, string wallet)
|
|
{
|
|
long sum = 0;
|
|
if (goods != null)
|
|
foreach (var p in goods.Properties())
|
|
{
|
|
string w;
|
|
if (walletOf.TryGetValue(p.Name, out w) && w == wallet) sum += Int(p.Value);
|
|
}
|
|
return (int)Math.Min(int.MaxValue, sum);
|
|
}
|
|
|
|
/// <summary>계정 응답(GET /tks/account)의 골드 — 재화 번호는 서버 재화 목록으로 푼다(확인 · 테스트용).</summary>
|
|
public int GoldOf(ServerResult account)
|
|
{
|
|
return WalletSum(account.At("goods") as JObject, WalletGold);
|
|
}
|
|
|
|
static List<CountEntry> CountList(JObject map)
|
|
{
|
|
var list = new List<CountEntry>();
|
|
if (map != null)
|
|
foreach (var p in map.Properties())
|
|
{
|
|
int n = Int(p.Value);
|
|
if (n > 0) list.Add(new CountEntry { id = p.Name, n = n });
|
|
}
|
|
return list;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 서버의 계정 전체 상태를 기기 세이브에 덮는다(서버가 관리하는 칸만 — 나머지는 기기 값 그대로).
|
|
/// first = 접속 직후(신규 계정 여부 · 서버 시각 맞춤).
|
|
/// </summary>
|
|
internal void ApplySnapshot(ServerResult r, bool first)
|
|
{
|
|
var j = r.json;
|
|
if (j == null) return;
|
|
var d = Save;
|
|
|
|
var serverNow = SaveStore.ParseIso((string)j["serverTime"], DateTime.UtcNow);
|
|
clockOffset = serverNow - DateTime.UtcNow; // 응답이 오는 동안만큼 서버보다 늦다 = 기기가 군량을 서버보다 많다고 보는 일은 없다
|
|
|
|
var goods = j["goods"] as JObject;
|
|
d.gold = WalletSum(goods, WalletGold);
|
|
d.gem = WalletSum(goods, WalletGem);
|
|
d.inv.books.skill = WalletSum(goods, WalletSkillBook);
|
|
|
|
var stamina = j.SelectToken("account.stamina");
|
|
if (stamina != null)
|
|
{
|
|
d.stamina = Int(stamina["amount"]);
|
|
d.staminaAt = (string)stamina["at"] ?? d.staminaAt;
|
|
}
|
|
|
|
d.heroes = new List<HeroState>();
|
|
foreach (var h in j["heroes"] as JArray ?? new JArray())
|
|
{
|
|
var s = new HeroState { id = (string)h["id"], lv = Int(h["lv"]), exp = Int(h["exp"]), grade = (string)h["grade"] ?? "", gearTotal = Int(h["gearTotal"]), star = Int(h["star"]), shards = Int(h["shards"]) };
|
|
foreach (var g in h["gear"] as JArray ?? new JArray()) s.gear.Add((string)g ?? "");
|
|
var lv = h["skillLv"] as JArray;
|
|
if (lv != null && lv.Count >= 2) s.skillLv = new[] { Int(lv[0]), Int(lv[1]) };
|
|
d.heroes.Add(s);
|
|
}
|
|
d.units = new List<UnitState>();
|
|
foreach (var u in j["units"] as JArray ?? new JArray())
|
|
d.units.Add(new UnitState { id = (string)u["id"], lv = Int(u["lv"]), exp = Int(u["exp"]), count = Int(u["count"]) });
|
|
|
|
var presets = j.SelectToken("formation.presets") as JArray;
|
|
if (presets != null)
|
|
{
|
|
d.presets = new List<Preset>();
|
|
foreach (var p in presets)
|
|
{
|
|
var pr = new Preset();
|
|
foreach (var id in p["slots"] as JArray ?? new JArray()) pr.slots.Add((string)id ?? "");
|
|
d.presets.Add(pr);
|
|
}
|
|
d.presetIdx = Int(j.SelectToken("formation.presetIdx"));
|
|
}
|
|
|
|
d.stages = new List<StageState>();
|
|
foreach (var s in j.SelectToken("stage.stages") as JArray ?? new JArray())
|
|
d.stages.Add(new StageState { key = (string)s["key"], stars = Int(s["stars"]), clears = Int(s["clears"]) });
|
|
d.chapterMax = Mathf.Max(1, Int(j.SelectToken("stage.chapterMax")));
|
|
|
|
d.inv.gear = CountList(j["gear"] as JObject);
|
|
d.inv.chests = CountList(j["chests"] as JObject);
|
|
ApplyContent(j, goods);
|
|
|
|
if (first)
|
|
{
|
|
IsNewUser = r.Bool("isNew");
|
|
EnsureTimezone(j); // 시간대가 없는 계정이면 기기 시간대를 한 번 보낸다
|
|
}
|
|
HeroRules.Sanitize(Db, d, FormationSlots);
|
|
SyncWorldProgress();
|
|
Commit();
|
|
}
|
|
|
|
static float Flt(JToken t)
|
|
{
|
|
return t == null || (t.Type != JTokenType.Float && t.Type != JTokenType.Integer) ? 0f : (float)t.Value<double>();
|
|
}
|
|
|
|
static bool Flag(JToken t)
|
|
{
|
|
return t != null && t.Type == JTokenType.Boolean && (bool)t;
|
|
}
|
|
|
|
/// <summary>3단계(내정 · 등용 · 교역 · 보물) 상태를 기기 세이브에 덮는다.</summary>
|
|
void ApplyContent(JObject j, JObject goods)
|
|
{
|
|
var d = Save;
|
|
d.inv.iron = WalletSum(goods, WalletIron);
|
|
d.inv.blueprint = WalletSum(goods, WalletBlueprint);
|
|
d.inv.chestPoints = WalletSum(goods, WalletChestPoint);
|
|
d.arena.towerTickets = WalletSum(goods, WalletTowerTicket);
|
|
d.arena.medals = WalletSum(goods, WalletMedal);
|
|
|
|
var dev = j["dev"] as JObject;
|
|
if (dev != null)
|
|
{
|
|
d.dev.nodes = CountList(dev["nodes"] as JObject);
|
|
d.dev.blueprintSpent = Int(dev["blueprintSpent"]);
|
|
d.dev.hero = (string)dev["hero"] ?? "";
|
|
}
|
|
|
|
var training = j.SelectToken("training.list") as JArray;
|
|
if (training != null)
|
|
{
|
|
d.training = new List<TrainState>();
|
|
foreach (var t in training)
|
|
{
|
|
var ts = new TrainState { type = (string)t["type"], rank = Mathf.Max(1, Int(t["rank"])), commander = (string)t["commander"] ?? "" };
|
|
ts.lv = new int[TrainingTable.Stats.Length];
|
|
var lv = t["lv"] as JObject;
|
|
for (int i = 0; i < ts.lv.Length && lv != null; i++) ts.lv[i] = Int(lv[TrainingTable.Stats[i]]); // 서버는 항목 이름으로 준다
|
|
d.training.Add(ts);
|
|
}
|
|
}
|
|
|
|
var patrol = j["patrol"] as JObject;
|
|
if (patrol != null)
|
|
{
|
|
d.patrol.startAt = (string)patrol["startAt"] ?? d.patrol.startAt;
|
|
d.patrol.carryGear = Flt(patrol["carryGear"]);
|
|
d.patrol.carryChest = Flt(patrol["carryChest"]);
|
|
d.patrol.hero = (string)patrol["hero"] ?? "";
|
|
}
|
|
|
|
var gacha = j["gacha"] as JObject;
|
|
if (gacha != null)
|
|
{
|
|
d.gacha.pities = CountList(gacha["pities"] as JObject);
|
|
d.gacha.total = Int(gacha["total"]);
|
|
d.gacha.firstTenUsed = Flag(gacha["firstTenUsed"]);
|
|
d.gacha.pity = 0;
|
|
}
|
|
|
|
// 일일 횟수 · 상점 — 날짜는 서버 날짜가 기준이다. 기기 쪽 날짜 칸에는 「오늘」을 적어 기기 규칙이 따로 초기화하지 않게 한다
|
|
string today = EconomyRules.DayKey(Now);
|
|
string serverDay = (string)j.SelectToken("daily.day") ?? "";
|
|
var counts = j.SelectToken("daily.counts") as JObject;
|
|
d.adsUsed = new AdsUsed
|
|
{
|
|
day = today,
|
|
stamina = counts != null ? Int(counts["adStamina"]) : 0,
|
|
patrol = counts != null ? Int(counts["patrolAd"]) : 0,
|
|
gemStamina = counts != null ? Int(counts["gemStamina"]) : 0,
|
|
gacha = d.adsUsed != null ? d.adsUsed.gacha : 0,
|
|
};
|
|
var shop = j["shop"] as JObject;
|
|
if (shop != null)
|
|
{
|
|
d.shop.day = today;
|
|
d.shop.refreshes = Int(shop["refreshes"]);
|
|
d.shop.items = new List<ShopItem>();
|
|
foreach (var it in shop["items"] as JArray ?? new JArray())
|
|
d.shop.items.Add(new ShopItem { gearId = (string)it["gearId"], price = Int(it["price"]), sold = Flag(it["sold"]) });
|
|
bool boughtToday = serverDay.Length > 0 && (string)shop["bookDay"] == serverDay;
|
|
d.shop.bookDay = boughtToday ? today : "";
|
|
d.shop.bookBought = boughtToday ? Int(shop["bookBought"]) : 0;
|
|
}
|
|
|
|
var treasures = j["treasures"] as JArray;
|
|
if (treasures != null)
|
|
{
|
|
d.inv.treasures = new List<TreasureState>();
|
|
foreach (var t in treasures) d.inv.treasures.Add(new TreasureState { id = (string)t["id"], star = Int(t["star"]), shards = Int(t["shards"]) });
|
|
}
|
|
d.counters = CountList(j["counters"] as JObject);
|
|
ApplyArena(j["arena"] as JObject, counts, today);
|
|
}
|
|
|
|
/// <summary>4단계(연무장) 상태 · 일일 횟수를 기기 세이브에 덮는다. 탑 입장권 · 메달은 재화에서 온다(ApplyContent).</summary>
|
|
void ApplyArena(JObject arena, JObject counts, string today)
|
|
{
|
|
var d = Save;
|
|
// 일일 횟수 — 날짜 칸에는 기기의 「오늘」을 적어 기기 규칙이 따로 초기화하지 않게 한다(서버 날짜가 기준)
|
|
var daily = new DailyC { day = today, freeRefresh = d.dailyC != null ? d.dailyC.freeRefresh : 0 };
|
|
if (counts != null)
|
|
{
|
|
daily.arena = Int(counts["arena"]);
|
|
daily.raid = Int(counts["raid"]);
|
|
daily.towerAd = Int(counts["towerAd"]);
|
|
daily.arenaShop = Int(counts["arenaShop"]);
|
|
foreach (var p in counts.Properties())
|
|
if (p.Name.StartsWith(DungeonCountPrefix, StringComparison.Ordinal) && Int(p.Value) > 0)
|
|
daily.dungeons.Add(new CountEntry { id = p.Name.Substring(DungeonCountPrefix.Length), n = Int(p.Value) });
|
|
}
|
|
d.dailyC = daily;
|
|
if (arena == null) return;
|
|
|
|
var a = d.arena;
|
|
a.server = true; // 시즌 · 상대 · 이번 주 보스 · 순위는 서버가 정한다(기기 규칙 ArenaRules 가 따로 굴리지 않는다)
|
|
a.towerFloor = Int(arena["towerFloor"]);
|
|
a.seasonScore = Int(arena["seasonScore"]);
|
|
a.seasonStart = (string)arena.SelectToken("season.startAt") ?? "";
|
|
a.wins = Int(arena["wins"]);
|
|
a.losses = Int(arena["losses"]);
|
|
a.rank = Int(arena["rank"]);
|
|
a.rankTotal = Int(arena["rankTotal"]);
|
|
a.raidWeek = (string)arena.SelectToken("raid.week") ?? "";
|
|
a.raidBoss = (string)arena.SelectToken("raid.boss") ?? "";
|
|
a.raidDamage = Int(arena.SelectToken("raid.damage"));
|
|
// 주간 랭킹 정산 시간(지금 진행 중이거나 다음에 올 것) — 이 동안 랭킹 관련 컨텐츠를 쓸 수 없다(ArenaRules.Settling)
|
|
var settle = arena["settle"] as JObject;
|
|
a.settleStart = settle != null ? (string)settle["startAt"] ?? "" : "";
|
|
a.settleEnd = settle != null ? (string)settle["endAt"] ?? "" : "";
|
|
a.settleContents = new List<string>();
|
|
if (settle != null)
|
|
foreach (var c in settle["contents"] as JArray ?? new JArray()) a.settleContents.Add((string)c ?? "");
|
|
var last = arena["lastSeason"] as JObject;
|
|
a.lastSeason = last == null ? "" : "지난 시즌 " + (Int(last["rank"]) > 0 ? Int(last["rank"]) + "위" : "순위 밖") + " · 보옥 +" + Int(last["gem"]);
|
|
a.samples = new List<ArenaSample>();
|
|
foreach (var o in arena["opponents"] as JArray ?? new JArray())
|
|
{
|
|
var sample = new ArenaSample { score = Int(o["score"]) };
|
|
foreach (var u in o["units"] as JArray ?? new JArray())
|
|
{
|
|
var unit = new ArenaUnit { id = (string)u["id"] ?? "", lv = Mathf.Max(1, Int(u["lv"])), grade = (string)u["grade"] ?? "", star = Int(u["star"]) };
|
|
sample.units.Add(unit);
|
|
sample.heroes.Add(unit.id);
|
|
sample.lv = Mathf.Max(sample.lv, unit.lv);
|
|
}
|
|
string name = (string)o["name"] ?? "";
|
|
if (name.Length == 0)
|
|
{
|
|
// 대역(실제 유저가 모자랄 때 서버가 채운 상대) = 대표 영웅 이름으로 짓는다(기기 규칙 ArenaRules.MakeSamples 와 같은 모양)
|
|
var lead = sample.heroes.Count > 0 ? Db.Heroes.Get(sample.heroes[0]) : null;
|
|
name = (lead != null ? lead.nameKo : "?") + " 군 · Lv " + sample.lv;
|
|
}
|
|
sample.name = name;
|
|
a.samples.Add(sample);
|
|
}
|
|
}
|
|
|
|
// ---------- 기기 → 서버 (기기에서 먼저 반영 → 같은 동작을 서버에 보냄) ----------
|
|
|
|
public override string LevelUp(string id)
|
|
{
|
|
var why = base.LevelUp(id);
|
|
if (why == null) Sync.Post("POST", (Save.Hero(id) != null ? "/tks/heroes/" : "/tks/units/") + Esc(id) + "/level-up", null);
|
|
return why;
|
|
}
|
|
|
|
public override string Equip(string id, int slot)
|
|
{
|
|
var why = base.Equip(id, slot);
|
|
if (why == null) Sync.Post("POST", "/tks/heroes/" + Esc(id) + "/gear", () => Json(o => o["slot"] = slot));
|
|
return why;
|
|
}
|
|
|
|
public override string Promote(string id)
|
|
{
|
|
var why = base.Promote(id);
|
|
if (why == null) Sync.Post("POST", "/tks/heroes/" + Esc(id) + "/promote", null);
|
|
return why;
|
|
}
|
|
|
|
public override string Evolve(string id)
|
|
{
|
|
var why = base.Evolve(id);
|
|
if (why == null) Sync.Post("POST", "/tks/heroes/" + Esc(id) + "/evolve", null);
|
|
return why;
|
|
}
|
|
|
|
public override string SkillUp(string id, int i)
|
|
{
|
|
var why = base.SkillUp(id, i);
|
|
if (why == null) Sync.Post("POST", "/tks/heroes/" + Esc(id) + "/skill-up", () => Json(o => o["index"] = i));
|
|
return why;
|
|
}
|
|
|
|
public override string SavePreset(int idx, List<string> slots)
|
|
{
|
|
var why = base.SavePreset(idx, slots);
|
|
if (why != null) return why;
|
|
var saved = new JArray();
|
|
foreach (var id in Save.presets[idx].slots) saved.Add(id ?? "");
|
|
Sync.Post("PUT", "/tks/formation/presets/" + idx.ToString(CultureInfo.InvariantCulture), () => Json(o => o["slots"] = saved));
|
|
return null;
|
|
}
|
|
|
|
public override string BuyStamina()
|
|
{
|
|
var why = base.BuyStamina();
|
|
if (why == null) Sync.Post("POST", "/tks/stamina/buy", null);
|
|
return why;
|
|
}
|
|
|
|
// ---------- 3단계: 내정 · 교역 · 보물 (기기에서 먼저 반영 → 서버에 보냄) ----------
|
|
|
|
public override string AdStamina()
|
|
{
|
|
var why = base.AdStamina();
|
|
if (why == null) Sync.Post("POST", "/tks/stamina/ad", null);
|
|
return why;
|
|
}
|
|
|
|
public override string DevUpgrade(string id)
|
|
{
|
|
var why = base.DevUpgrade(id);
|
|
if (why == null) Sync.Post("POST", "/tks/dev/nodes/" + Esc(id) + "/upgrade", null);
|
|
return why;
|
|
}
|
|
|
|
public override string DevReset()
|
|
{
|
|
var why = base.DevReset();
|
|
if (why == null) Sync.Post("POST", "/tks/dev/reset", null);
|
|
return why;
|
|
}
|
|
|
|
public override string TrainLevel(UnitType t, int stat)
|
|
{
|
|
var why = base.TrainLevel(t, stat);
|
|
if (why == null) Sync.Post("POST", "/tks/training/" + Esc(UnitTypeInfo.Key(t)) + "/upgrade", () => Json(o => o["stat"] = TrainingTable.Stats[stat]));
|
|
return why;
|
|
}
|
|
|
|
public override string TrainPromote(UnitType t)
|
|
{
|
|
var why = base.TrainPromote(t);
|
|
if (why == null) Sync.Post("POST", "/tks/training/" + Esc(UnitTypeInfo.Key(t)) + "/rank-up", null);
|
|
return why;
|
|
}
|
|
|
|
public override string Dispatch(string slot, string heroId)
|
|
{
|
|
var why = base.Dispatch(slot, heroId);
|
|
if (why == null)
|
|
Sync.Post("PUT", "/tks/dispatch", () => Json(o =>
|
|
{
|
|
o["slot"] = slot;
|
|
o["heroId"] = heroId ?? "";
|
|
}));
|
|
return why;
|
|
}
|
|
|
|
public override string EnhanceTreasure(string id)
|
|
{
|
|
var why = base.EnhanceTreasure(id);
|
|
if (why == null) Sync.Post("POST", "/tks/treasures/" + Esc(id) + "/upgrade", null);
|
|
return why;
|
|
}
|
|
|
|
public override string BuyChest(string id, string currency)
|
|
{
|
|
var why = base.BuyChest(id, currency);
|
|
if (why == null) Sync.Post("POST", "/tks/chests/" + Esc(id) + "/buy", () => Json(o => o["currency"] = currency));
|
|
return why;
|
|
}
|
|
|
|
/// <summary>진열은 서버가 깐다(계정 수신 때 오늘 것으로 온다) — 기기에서 새로 깔지 않는다.</summary>
|
|
public override void EnsureShop()
|
|
{
|
|
}
|
|
|
|
public override string BuyShop(int index)
|
|
{
|
|
var why = base.BuyShop(index);
|
|
if (why == null) Sync.Post("POST", "/tks/shop/buy", () => Json(o => o["index"] = index));
|
|
return why;
|
|
}
|
|
|
|
// ---------- 3단계: 결과를 서버가 정하는 동작 (응답을 기다린다 → 서버 상태로 맞춘 뒤 done) ----------
|
|
|
|
/// <summary>서버가 거절했을 때 화면에 보여 줄 말(이유 코드).</summary>
|
|
static string Refused(ServerResult r)
|
|
{
|
|
return "서버가 받아 주지 않았습니다 (" + r.Message + ")";
|
|
}
|
|
|
|
public override void DrawAsync(GachaConfig.Banner banner, int count, Action<List<GachaPull>> done)
|
|
{
|
|
if (GachaRules.CanDraw(Db, Save, banner, count, Now) != null)
|
|
{
|
|
done(new List<GachaPull>());
|
|
return;
|
|
}
|
|
Sync.Post("POST", "/tks/gacha/" + Esc(banner.id) + "/draw", () => Json(o => o["count"] = count),
|
|
r =>
|
|
{
|
|
var pulls = new List<GachaPull>();
|
|
for (int i = 0; i < r.Count("pulls"); i++)
|
|
{
|
|
string p = "pulls[" + i.ToString(CultureInfo.InvariantCulture) + "].";
|
|
pulls.Add(new GachaPull
|
|
{
|
|
heroId = r.Str(p + "heroId"), tier = (int)r.Num(p + "tier"), isNew = r.Bool(p + "isNew"), pickup = r.Bool(p + "pickup"),
|
|
pity = r.Bool(p + "pity"), shards = (int)r.Num(p + "shards"), gold = (int)r.Num(p + "gold"),
|
|
});
|
|
}
|
|
done(pulls);
|
|
},
|
|
r => done(new List<GachaPull>()), true, true);
|
|
}
|
|
|
|
static PatrolYield YieldFrom(ServerResult r)
|
|
{
|
|
var y = new PatrolYield
|
|
{
|
|
hours = r.Float("yield.hours"), mult = r.Float("yield.mult"), gold = (int)r.Num("yield.gold"), exp = (int)r.Num("yield.exp"),
|
|
gearGrade = r.Str("yield.gearGrade"), gear = (int)r.Num("yield.gear"), chests = (int)r.Num("yield.chests"),
|
|
gearF = r.Float("yield.gearF"), chestF = r.Float("yield.chestF"),
|
|
};
|
|
y.gearIds = r.Strings("yield.gearIds");
|
|
y.chestIds = r.Strings("yield.chestIds");
|
|
y.expTo = r.Strings("yield.expTo");
|
|
return y;
|
|
}
|
|
|
|
public override void HarvestAsync(bool ad, Action<PatrolYield, string> done)
|
|
{
|
|
if (PatrolRules.Hours(Db, Save, Now) <= 0f)
|
|
{
|
|
done(null, "쌓인 수확 없음");
|
|
return;
|
|
}
|
|
Sync.Post("POST", "/tks/patrol/harvest", () => Json(o => o["ad"] = ad), r => done(YieldFrom(r), null), r => done(null, Refused(r)), true, true);
|
|
}
|
|
|
|
public override void InstantHarvestAsync(Action<PatrolYield, string> done)
|
|
{
|
|
int cost = Db.Economy.PatrolInstantGem;
|
|
if (Save.gem < cost)
|
|
{
|
|
done(null, "보옥 부족 " + Save.gem + " / " + cost);
|
|
return;
|
|
}
|
|
Sync.Post("POST", "/tks/patrol/instant", null, r => done(YieldFrom(r), null), r => done(null, Refused(r)), true, true);
|
|
}
|
|
|
|
public override void OpenChestAsync(string id, Action<ChestResult> done)
|
|
{
|
|
if (TreasureRules.ChestCount(Save, id) <= 0)
|
|
{
|
|
done(null);
|
|
return;
|
|
}
|
|
Sync.Post("POST", "/tks/chests/" + Esc(id) + "/open", null,
|
|
r => done(new ChestResult
|
|
{
|
|
chestId = id,
|
|
treasureId = r.Has("result.treasureId") ? r.Str("result.treasureId") : null,
|
|
grade = r.Has("result.grade") ? r.Str("result.grade") : null,
|
|
isNew = r.Bool("result.isNew"), shards = (int)r.Num("result.shards"), gradeUp = r.Bool("result.gradeUp"),
|
|
gold = (int)r.Num("result.gold"), gem = (int)r.Num("result.gem"), iron = (int)r.Num("result.iron"),
|
|
points = (int)r.Num("result.points"), bonusChests = (int)r.Num("result.bonusChests"),
|
|
}),
|
|
r => done(null), true, true);
|
|
}
|
|
|
|
public override void RefreshShopAsync(Action<string> done)
|
|
{
|
|
int cost = EconomyRules.FreeRefreshesLeft(Db, Save) > 0 ? 0 : Db.Economy.ShopRefreshGem;
|
|
if (Save.gem < cost)
|
|
{
|
|
done("보옥 부족 " + Save.gem + " / " + cost);
|
|
return;
|
|
}
|
|
Sync.Post("POST", "/tks/shop/refresh", null, r => done(null), r => done(Refused(r)), true, true);
|
|
}
|
|
|
|
public override void SweepAsync(BalanceConfig.StageDef s, Action<StageReward> done)
|
|
{
|
|
TickStamina();
|
|
int cost = EconomyRules.StageCost(Db, Save, s);
|
|
if (!EconomyRules.CanSweep(Save, s) || Save.stamina < cost)
|
|
{
|
|
done(null);
|
|
return;
|
|
}
|
|
Sync.Post("POST", "/tks/stages/sweep",
|
|
() => Json(o =>
|
|
{
|
|
o["chapter"] = s.chapter;
|
|
o["stage"] = s.stage;
|
|
}),
|
|
r =>
|
|
{
|
|
var reward = RewardFrom(r, s, cost);
|
|
reward.sweep = true;
|
|
var st = Save.Stage(s.chapter, s.stage, false);
|
|
reward.bestStars = st != null ? st.stars : 0;
|
|
for (int i = 0; i < r.Count("heroes"); i++) reward.expTo.Add(r.Str("heroes[" + i.ToString(CultureInfo.InvariantCulture) + "].id"));
|
|
for (int i = 0; i < r.Count("units"); i++) reward.expTo.Add(r.Str("units[" + i.ToString(CultureInfo.InvariantCulture) + "].id"));
|
|
LastReward = reward;
|
|
done(reward);
|
|
},
|
|
r => done(null), true, true);
|
|
}
|
|
|
|
// ---------- 4단계: 연무장 ----------
|
|
|
|
/// <summary>시즌 · 상대 목록 · 이번 주 보스 · 탑 입장권은 서버가 맞춘다 — 날짜가 넘어갔을 수 있으니 계정 상태를 한 번 다시 받는다.</summary>
|
|
public override void ArenaEnter()
|
|
{
|
|
Sync.Refresh();
|
|
}
|
|
|
|
public override string TowerAd()
|
|
{
|
|
var why = base.TowerAd();
|
|
if (why == null) Sync.Post("POST", "/tks/arena/tower/ad", null);
|
|
return why;
|
|
}
|
|
|
|
public override string BuyArenaShards(string heroId)
|
|
{
|
|
var why = base.BuyArenaShards(heroId);
|
|
if (why == null) Sync.Post("POST", "/tks/arena/shop/buy", () => Json(o => o["heroId"] = heroId));
|
|
return why;
|
|
}
|
|
|
|
/// <summary>연무장 입장 — 기기에서는 전투를 바로 시작하고, 서버 입장(세션 발급)은 줄을 서서 뒤따른다.</summary>
|
|
public override void BeginMode(string kind, string id, int index)
|
|
{
|
|
base.BeginMode(kind, id, index);
|
|
modeEntry = Entry.Pending;
|
|
modeSession = null;
|
|
countersAtEntry.Clear();
|
|
foreach (var c in Save.counters) countersAtEntry[c.id] = c.n;
|
|
string path;
|
|
Func<string> body = null;
|
|
switch (kind)
|
|
{
|
|
case ArenaRules.Tower:
|
|
path = "/tks/arena/tower/start";
|
|
break;
|
|
case ArenaRules.Dungeon:
|
|
path = "/tks/arena/dungeons/" + Esc(id) + "/start";
|
|
break;
|
|
case ArenaRules.Arena:
|
|
path = "/tks/arena/pvp/start";
|
|
body = () => Json(o => o["index"] = index);
|
|
break;
|
|
case ArenaRules.Raid:
|
|
path = "/tks/arena/raid/start";
|
|
break;
|
|
default:
|
|
modeEntry = Entry.Rejected;
|
|
return;
|
|
}
|
|
Sync.Post("POST", path, body,
|
|
r =>
|
|
{
|
|
modeSession = r.Str("sessionId");
|
|
modeEntry = Entry.Ok;
|
|
},
|
|
r => modeEntry = Entry.Rejected);
|
|
}
|
|
|
|
/// <summary>이번 전투에서 늘어난 보물 조건 누적(밀치기 · 스킬 사용 · 보스 처치 …) — 전투 수 · 골드 사용 · 순찰은 서버가 센다.</summary>
|
|
JObject GainedCounters()
|
|
{
|
|
var gained = new JObject();
|
|
foreach (var c in Save.counters)
|
|
{
|
|
int before;
|
|
countersAtEntry.TryGetValue(c.id, out before);
|
|
if (c.n > before && Array.IndexOf(ServerCounted, c.id) < 0) gained[c.id] = c.n - before;
|
|
}
|
|
return gained;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 연무장 종료 — 서버에 결과(승패 · 턴 수 · 토벌 피해)를 보내고 **응답의 보상**을 보여 준다. 여기서는 null 을 돌려주고, 응답이 오면 ModeReady 로 알린다.
|
|
/// 서버에 입장 기록이 없는 전투(입장을 서버가 거절)는 보상 없이 바로 결과를 돌려준다.
|
|
/// </summary>
|
|
public override ModeResult OnModeEnd(BattleManager bm, bool win)
|
|
{
|
|
var m = Mode;
|
|
if (m == null) return null;
|
|
Mode = null;
|
|
int turns = bm.TurnNumber;
|
|
bool raid = m.kind == ArenaRules.Raid;
|
|
int dmg = 0;
|
|
bool killed = false;
|
|
if (raid)
|
|
foreach (var u in bm.Units)
|
|
{
|
|
if (u == null || u.Faction != Faction.Enemy || !u.IsBoss) continue;
|
|
dmg += u.MaxHp - u.Hp;
|
|
killed |= !u.IsAlive;
|
|
}
|
|
ArenaRules.CountBattle(Save, bm); // 보물 조건 효과(전투 · 보스 처치)
|
|
var gained = GainedCounters();
|
|
LastMode = null;
|
|
var entered = modeEntry;
|
|
modeEntry = Entry.None;
|
|
if (entered == Entry.None || entered == Entry.Rejected)
|
|
{
|
|
LastMode = UnrecordedMode(m, win);
|
|
return LastMode;
|
|
}
|
|
Sync.Post("POST", "/tks/arena/end",
|
|
() => Json(o =>
|
|
{
|
|
o["sessionId"] = modeSession ?? "";
|
|
o["win"] = win;
|
|
o["turns"] = turns;
|
|
if (raid)
|
|
{
|
|
o["damage"] = dmg;
|
|
o["killed"] = killed;
|
|
}
|
|
if (gained.Count > 0) o["counters"] = gained;
|
|
}),
|
|
r =>
|
|
{
|
|
LastMode = ModeFrom(r, m); // 이 시점의 세이브 = 응답 직후 서버 상태로 맞춘 값
|
|
Commit();
|
|
RaiseModeReady(LastMode);
|
|
},
|
|
r =>
|
|
{
|
|
LastMode = UnrecordedMode(m, win);
|
|
RaiseModeReady(LastMode);
|
|
},
|
|
true, true);
|
|
return null;
|
|
}
|
|
|
|
void AddChestLine(ModeResult res, ServerResult r)
|
|
{
|
|
if (!r.Has("reward.chest")) return;
|
|
var chest = Db.Chests.Get(r.Str("reward.chest"));
|
|
res.lines.Add((chest != null ? chest.nameKo : r.Str("reward.chest")) + " 획득");
|
|
}
|
|
|
|
/// <summary>서버 응답 → 결과 화면에 보여 줄 줄(기기 규칙 ArenaRules.*Result 와 같은 말).</summary>
|
|
ModeResult ModeFrom(ServerResult r, ModeCtx m)
|
|
{
|
|
var d = Save;
|
|
bool win = r.Bool("win");
|
|
var res = new ModeResult { kind = m.kind, win = win };
|
|
switch (m.kind)
|
|
{
|
|
case ArenaRules.Tower:
|
|
res.title = "천하제일 탑 " + m.index + "층";
|
|
if (!win)
|
|
{
|
|
res.lines.Add("도전 실패 — 입장권 1장 소모 · 층 유지");
|
|
break;
|
|
}
|
|
res.lines.Add("보옥 +" + r.Num("reward.gem") + " · 도면 +" + r.Num("reward.blueprint"));
|
|
AddChestLine(res, r);
|
|
res.lines.Add("다음 = " + ArenaRules.TowerNext(Db, d) + "층");
|
|
break;
|
|
case ArenaRules.Dungeon:
|
|
var dg = Db.Dungeons.Get(m.id);
|
|
res.title = (dg != null ? dg.nameKo : m.id) + " 던전";
|
|
if (!win)
|
|
{
|
|
res.lines.Add("도전 실패 — 입장 횟수 유지");
|
|
break;
|
|
}
|
|
if (r.Num("reward.gold") > 0) res.lines.Add("골드 +" + r.Num("reward.gold").ToString("N0"));
|
|
if (r.Num("reward.iron") > 0) res.lines.Add("운철 +" + r.Num("reward.iron"));
|
|
if (r.Num("reward.skillBook") > 0) res.lines.Add("스킬서 +" + r.Num("reward.skillBook"));
|
|
foreach (var gearId in r.Strings("reward.gearIds"))
|
|
{
|
|
var g = Db.Gear.Get(gearId);
|
|
res.lines.Add("장비 " + (g != null ? g.nameKo + " (" + UiKit.GradeKo(g.grade) + ")" : gearId));
|
|
}
|
|
if (r.Has("reward.shards"))
|
|
{
|
|
var hd = Db.Heroes.Get(r.Str("reward.shards.heroId"));
|
|
res.lines.Add((hd != null ? hd.nameKo : r.Str("reward.shards.heroId")) + " 조각 +" + r.Num("reward.shards.amount"));
|
|
}
|
|
if (dg != null) res.lines.Add("오늘 남은 입장 " + ArenaRules.DungeonLeft(Db, d, dg, Now) + " / " + dg.entriesPerDay);
|
|
break;
|
|
case ArenaRules.Arena:
|
|
res.title = "투기장 " + (win ? "승리" : "패배");
|
|
var sample = m.index >= 0 && m.index < d.arena.samples.Count ? d.arena.samples[m.index] : null;
|
|
res.lines.Add((sample != null ? sample.name : "상대") + " 상대");
|
|
res.lines.Add("메달 +" + r.Num("reward.medals") + " (보유 " + d.arena.medals + ")");
|
|
res.lines.Add("주간 점수 " + d.arena.seasonScore + " · 순위 " + ArenaRules.Rank(d) + "위");
|
|
res.lines.Add("오늘 남은 도전 " + ArenaRules.ArenaLeft(Db, d, Now) + " / " + Db.Arena.EntriesPerDay);
|
|
break;
|
|
case ArenaRules.Raid:
|
|
var boss = Db.Heroes.Get(m.id);
|
|
res.win = true;
|
|
res.title = "적장 토벌 — " + (boss != null ? boss.nameKo : m.id);
|
|
res.lines.Add("이번 피해 " + r.Num("damage").ToString("N0") + (r.Bool("killed") ? " (격파!)" : ""));
|
|
res.lines.Add("이번 주 누적 " + r.Num("raidDamage").ToString("N0"));
|
|
AddChestLine(res, r);
|
|
if (r.Has("reward.treasure"))
|
|
{
|
|
var t = Db.Treasures.Get(r.Str("reward.treasure.id"));
|
|
res.lines.Add("천기 보물 " + (t != null ? t.nameKo : r.Str("reward.treasure.id")) + (r.Bool("reward.treasure.isNew") ? " 획득!" : " 조각 +" + r.Num("reward.treasure.shards")));
|
|
}
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/// <summary>서버에 기록되지 않은 연무장 전투의 결과 — 보상 없음.</summary>
|
|
static ModeResult UnrecordedMode(ModeCtx m, bool win)
|
|
{
|
|
var res = new ModeResult { kind = m.kind, win = win, title = "연무장" };
|
|
res.lines.Add("서버에 입장 기록이 없어 보상이 지급되지 않았습니다");
|
|
return res;
|
|
}
|
|
|
|
// ---------- 4단계: 순위 표 ----------
|
|
|
|
public override bool RankAvailable
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
/// <summary>순위 표 — 몇 명을 보여 줄지는 서버가 정한다(주소에 수를 붙이지 않는다). 다른 유저의 ID 는 오지 않는다.</summary>
|
|
public override void RankBoardAsync(string board, Action<RankBoard, string> done)
|
|
{
|
|
Sync.Post("GET", "/tks/leaderboard/" + Esc(board), null,
|
|
r =>
|
|
{
|
|
var b = new RankBoard { board = board, myRank = Int(r.At("me.rank")), myScore = Long(r.At("me.score")), total = Int(r.At("me.total")) };
|
|
foreach (var t in r.At("top") as JArray ?? new JArray())
|
|
b.top.Add(new RankRow { rank = Int(t["rank"]), name = (string)t["nickname"] ?? "", score = Long(t["score"]), me = Flag(t["me"]) });
|
|
done(b, null);
|
|
},
|
|
r => done(null, Refused(r)), true, false, true);
|
|
}
|
|
|
|
static long Long(JToken t)
|
|
{
|
|
if (t == null || t.Type == JTokenType.Null) return 0;
|
|
long n;
|
|
return long.TryParse(t.ToString(), NumberStyles.Integer, CultureInfo.InvariantCulture, out n) ? n : 0;
|
|
}
|
|
|
|
// ---------- 공지사항 ----------
|
|
|
|
/// <summary>공지 목록 — 글은 게임 언어 칸을 고르고(없으면 처음 있는 글 = 한국어) 화면용 모양으로 바꾼다.</summary>
|
|
public override void NoticeListAsync(Action<List<NoticeItem>, string> done)
|
|
{
|
|
Sync.Post("GET", "/tks/notices", null,
|
|
r =>
|
|
{
|
|
var list = new List<NoticeItem>();
|
|
foreach (var n in r.At("notices") as JArray ?? new JArray())
|
|
list.Add(new NoticeItem
|
|
{
|
|
id = Int(n["id"]), title = Localized(n["title"]), body = Localized(n["body"]),
|
|
startAt = SaveStore.ParseIso((string)n["startAt"], DateTime.MinValue), endAt = SaveStore.ParseIso((string)n["endAt"], DateTime.MinValue),
|
|
});
|
|
done(list, null);
|
|
},
|
|
r => done(null, Refused(r)), true, false, true);
|
|
}
|
|
|
|
// ---------- 4단계: 우편 · 쿠폰 ----------
|
|
|
|
public override bool MailAvailable
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
/// <summary>우편 글 — 언어 칸(ko)이 없으면 처음 있는 글.</summary>
|
|
static string Localized(JToken t)
|
|
{
|
|
var o = t as JObject;
|
|
if (o == null) return "";
|
|
var own = (string)o[MailLang];
|
|
if (!string.IsNullOrEmpty(own)) return own;
|
|
foreach (var p in o.Properties())
|
|
if (p.Value.Type == JTokenType.String) return (string)p.Value;
|
|
return "";
|
|
}
|
|
|
|
/// <summary>보상 목록 → 「골드 500 · 청동 상자 1」 (같은 것은 합친다).</summary>
|
|
string RewardText(JArray rewards)
|
|
{
|
|
var names = new List<string>();
|
|
var amounts = new List<long>();
|
|
foreach (var w in rewards ?? new JArray())
|
|
{
|
|
string type = (string)w["type"] ?? "", id = (string)w["id"] ?? "", name = id;
|
|
if (type == RewardGoods)
|
|
{
|
|
string wallet;
|
|
if (walletOf.TryGetValue(id, out wallet) && WalletName.ContainsKey(wallet)) name = WalletName[wallet];
|
|
}
|
|
else if (type == RewardGear)
|
|
{
|
|
var g = Db.Gear.Get(id);
|
|
if (g != null) name = g.nameKo;
|
|
}
|
|
else if (type == RewardChest)
|
|
{
|
|
var c = Db.Chests.Get(id);
|
|
if (c != null) name = c.nameKo;
|
|
}
|
|
int at = names.IndexOf(name);
|
|
if (at < 0)
|
|
{
|
|
names.Add(name);
|
|
amounts.Add(Int(w["amount"]));
|
|
}
|
|
else amounts[at] += Int(w["amount"]);
|
|
}
|
|
var parts = new List<string>();
|
|
for (int i = 0; i < names.Count; i++) parts.Add(names[i] + " " + amounts[i].ToString("N0"));
|
|
return string.Join(" · ", parts.ToArray());
|
|
}
|
|
|
|
public override void MailListAsync(Action<List<MailItem>, string> done)
|
|
{
|
|
Sync.Post("GET", "/tks/mail", null,
|
|
r =>
|
|
{
|
|
var list = new List<MailItem>();
|
|
foreach (var m in r.At("mails") as JArray ?? new JArray())
|
|
{
|
|
var rewards = m["rewards"] as JArray;
|
|
list.Add(new MailItem
|
|
{
|
|
id = Int(m["mailId"]), title = Localized(m["title"]), body = Localized(m["description"]),
|
|
rewards = RewardText(rewards), hasRewards = rewards != null && rewards.Count > 0,
|
|
until = SaveStore.ParseIso((string)m["expiredAt"], DateTime.MinValue),
|
|
});
|
|
}
|
|
done(list, null);
|
|
},
|
|
r => done(null, Refused(r)), true, false, true);
|
|
}
|
|
|
|
public override void MailClaimAsync(List<int> ids, Action<string, bool> done)
|
|
{
|
|
var mailIds = new JArray();
|
|
foreach (var id in ids) mailIds.Add(id);
|
|
Sync.Post("POST", "/tks/mail/rewards", () => Json(o => o["mailIds"] = mailIds),
|
|
r =>
|
|
{
|
|
int got = 0, missed = 0;
|
|
var rewards = new JArray();
|
|
foreach (var x in r.At("results") as JArray ?? new JArray())
|
|
{
|
|
if (!Flag(x["success"]))
|
|
{
|
|
missed++;
|
|
continue;
|
|
}
|
|
got++;
|
|
foreach (var w in x["rewards"] as JArray ?? new JArray()) rewards.Add(w);
|
|
}
|
|
if (got == 0) done("받을 수 있는 우편이 없습니다", false);
|
|
else done("우편 " + got + "통 받음 — " + RewardText(rewards) + (missed > 0 ? "\n(받지 못한 우편 " + missed + "통)" : ""), true);
|
|
},
|
|
r => done(Refused(r), false), true, true, true);
|
|
}
|
|
|
|
public override void CouponAsync(string code, Action<string, bool> done)
|
|
{
|
|
code = (code ?? "").Trim();
|
|
if (code.Length == 0)
|
|
{
|
|
done("쿠폰 코드를 적어 주세요", false);
|
|
return;
|
|
}
|
|
Sync.Post("POST", "/tks/mail/coupons", () => Json(o => o["code"] = code),
|
|
r => done("쿠폰 보상 — " + RewardText(r.At("rewards") as JArray), true),
|
|
r =>
|
|
{
|
|
switch (r.Message)
|
|
{
|
|
case "COUPON_NOT_FOUND":
|
|
done("없는 쿠폰이거나 기간이 지났습니다", false);
|
|
break;
|
|
case "COUPON_ALREADY_USED":
|
|
done("이미 사용한 쿠폰입니다", false);
|
|
break;
|
|
case "COUPON_EXHAUSTED":
|
|
done("사용 수가 모두 찬 쿠폰입니다", false);
|
|
break;
|
|
default:
|
|
done("쓸 수 없는 쿠폰입니다", false);
|
|
break;
|
|
}
|
|
},
|
|
true, true, true);
|
|
}
|
|
|
|
// ---------- 전투 ----------
|
|
|
|
/// <summary>입장 — 기기에서 군량을 먼저 쓰고 전투를 시작한다. 서버 입장(세션 발급)은 줄을 서서 뒤따른다.</summary>
|
|
public override bool TryPayEntry(BalanceConfig.StageDef s)
|
|
{
|
|
if (!base.TryPayEntry(s)) return false;
|
|
entry = Entry.Pending;
|
|
stageSession = null;
|
|
countersAtEntry.Clear();
|
|
foreach (var c in Save.counters) countersAtEntry[c.id] = c.n;
|
|
Sync.Post("POST", "/tks/stages/start",
|
|
() => Json(o =>
|
|
{
|
|
o["chapter"] = s.chapter;
|
|
o["stage"] = s.stage;
|
|
}),
|
|
r =>
|
|
{
|
|
stageSession = r.Str("sessionId");
|
|
entry = Entry.Ok;
|
|
},
|
|
r => entry = Entry.Rejected);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 종료 — 서버에 결과(승패 · 전원 생존 · 턴 수)를 보내고 **응답의 보상**을 반영한다. 여기서는 null 을 돌려주고, 응답이 오면 RewardReady 로 알린다.
|
|
/// 서버에 입장 기록이 없는 전투(입장을 서버가 거절)는 보상 없이 바로 결과를 돌려준다.
|
|
/// </summary>
|
|
public override StageReward OnBattleEnd(BattleManager bm, bool win)
|
|
{
|
|
var stage = bm.Stage;
|
|
int alive = 0;
|
|
foreach (var u in bm.AliveUnits(Faction.Player))
|
|
if (!u.Npc) alive++;
|
|
bool allAlive = bm.Deployed.Count > 0 && alive >= bm.Deployed.Count;
|
|
int turns = bm.TurnNumber;
|
|
int cost = EconomyRules.StageCost(Db, Save, stage);
|
|
var ids = new List<string>();
|
|
foreach (var e in bm.Deployed) ids.Add(e.id);
|
|
ArenaRules.CountBattle(Save, bm); // 보물 조건 효과(전투 · 보스 처치)
|
|
LastReward = null;
|
|
// 이번 전투에서 늘어난 조건 누적(밀치기 · 스킬 사용 · 보스 처치 …)을 서버에 알린다 — 전투 수 · 골드 사용 · 순찰은 서버가 센다
|
|
var gained = new JObject();
|
|
foreach (var c in Save.counters)
|
|
{
|
|
int before;
|
|
countersAtEntry.TryGetValue(c.id, out before);
|
|
if (c.n > before && Array.IndexOf(ServerCounted, c.id) < 0) gained[c.id] = c.n - before;
|
|
}
|
|
|
|
if (entry == Entry.None || entry == Entry.Rejected)
|
|
{
|
|
entry = Entry.None;
|
|
return Unrecorded(stage, win, turns, cost);
|
|
}
|
|
entry = Entry.None;
|
|
Sync.Post("POST", "/tks/stages/end",
|
|
() => Json(o =>
|
|
{
|
|
o["sessionId"] = stageSession ?? "";
|
|
o["chapter"] = stage.chapter;
|
|
o["stage"] = stage.stage;
|
|
o["win"] = win;
|
|
o["allAlive"] = allAlive;
|
|
o["turns"] = turns;
|
|
if (gained.Count > 0) o["counters"] = gained;
|
|
}),
|
|
r =>
|
|
{
|
|
var reward = RewardFrom(r, stage, cost);
|
|
EconomyRules.Apply(Save, reward, ids); // 서버가 준 것과 같은 내용을 기기에 반영(뒤따르는 계정 수신이 다시 확인한다)
|
|
LastReward = reward;
|
|
Commit();
|
|
RaiseRewardReady(reward);
|
|
},
|
|
r => RaiseRewardReady(Unrecorded(stage, win, turns, cost)),
|
|
true);
|
|
return null;
|
|
}
|
|
|
|
static StageReward RewardFrom(ServerResult r, BalanceConfig.StageDef stage, int cost)
|
|
{
|
|
var reward = new StageReward
|
|
{
|
|
win = r.Bool("reward.win"),
|
|
first = r.Bool("reward.first"),
|
|
boss = r.Bool("reward.boss"),
|
|
chapter = stage.chapter,
|
|
stage = stage.stage,
|
|
gold = (int)r.Num("reward.gold"),
|
|
exp = (int)r.Num("reward.exp"),
|
|
gem = (int)r.Num("reward.gem"),
|
|
gearId = r.Has("reward.gearId") ? r.Str("reward.gearId") : null,
|
|
chest = r.Has("reward.chest") ? r.Str("reward.chest") : null,
|
|
stars = (int)r.Num("reward.stars"),
|
|
starTurns = (int)r.Num("reward.starTurns"),
|
|
turns = (int)r.Num("reward.turns"),
|
|
stamina = cost,
|
|
};
|
|
for (int i = 0; i < reward.conds.Length; i++) reward.conds[i] = r.Bool("reward.conds[" + i.ToString(CultureInfo.InvariantCulture) + "]");
|
|
return reward;
|
|
}
|
|
|
|
/// <summary>서버에 기록되지 않은 전투의 결과 — 보상 없음(진행도 저장되지 않는다).</summary>
|
|
StageReward Unrecorded(BalanceConfig.StageDef stage, bool win, int turns, int cost)
|
|
{
|
|
var row = Db.Rewards.For(stage.chapter);
|
|
var st = Save.Stage(stage.chapter, stage.stage, false);
|
|
var reward = new StageReward
|
|
{
|
|
win = win, chapter = stage.chapter, stage = stage.stage, boss = stage.kind == StageKind.Boss,
|
|
turns = turns, starTurns = row != null ? row.starTurns : 0, bestStars = st != null ? st.stars : 0, stamina = cost,
|
|
};
|
|
LastReward = reward;
|
|
if (OutGameRoot.Instance != null) OutGameRoot.Instance.Toast("서버에 입장 기록이 없어 보상이 지급되지 않았습니다");
|
|
return reward;
|
|
}
|
|
}
|
|
|
|
/// <summary>실행을 시작할 때 서버 모드 여부를 정해 세션 만드는 곳에 연결한다.</summary>
|
|
public static class ServerLink
|
|
{
|
|
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
|
|
static void Init()
|
|
{
|
|
Apply();
|
|
FromTitle = false;
|
|
UnityEngine.SceneManagement.SceneManager.sceneLoaded -= OnSceneLoaded; // 도메인 리로드를 끈 에디터에서 두 번 걸리지 않게
|
|
UnityEngine.SceneManagement.SceneManager.sceneLoaded += OnSceneLoaded;
|
|
}
|
|
|
|
/// <summary>타이틀 씬을 거쳐 들어왔는가 — 타이틀부터 다시 시작할 때(Restart) 돌아갈 곳을 정한다.</summary>
|
|
public static bool FromTitle { get; private set; }
|
|
|
|
/// <summary>
|
|
/// 타이틀 씬이 열리면(서버 모드) 그 씬에서 접속 · 로그인을 시작한다 — 로그인 화면이 타이틀 위에 뜨고, 로그인이 끝나야 타이틀이 다음으로 넘어간다
|
|
/// (타이틀 화면은 접속 일꾼이 있는지 · 끝났는지만 본다 — UI/TitleScreen 의 PressReady). 일꾼은 씬이 바뀌어도 남아 게임 씬의 세션이 이어받는다.
|
|
/// </summary>
|
|
static void OnSceneLoaded(UnityEngine.SceneManagement.Scene scene, UnityEngine.SceneManagement.LoadSceneMode mode)
|
|
{
|
|
if (!ServerConfig.Active || scene.name != BootScenes.Title) return;
|
|
FromTitle = true;
|
|
ServerSync.CreateAtTitle();
|
|
}
|
|
|
|
/// <summary>서버 모드면 세션을 ServerSession 으로 만들고, 기기 사본을 따로 둔 파일에 쓴다(기존 save.json 을 덮지 않는다).</summary>
|
|
public static void Apply()
|
|
{
|
|
if (ServerConfig.Active)
|
|
{
|
|
var file = ServerConfig.CacheFile;
|
|
SaveStore.FileOverride = string.IsNullOrEmpty(file) ? null : file;
|
|
OutGameSession.Factory = (db, cfg, save) => new ServerSession(db, cfg, save);
|
|
}
|
|
else
|
|
{
|
|
SaveStore.FileOverride = null;
|
|
OutGameSession.Factory = null;
|
|
}
|
|
}
|
|
|
|
/// <summary>게임 종료를 요청한 횟수(서버 점검 · 이용 제한 안내의 버튼) — 테스트가 본다.</summary>
|
|
public static int Quits { get; private set; }
|
|
/// <summary>마지막으로 연 스토어 주소(업데이트 안내의 버튼) — 테스트가 본다.</summary>
|
|
public static string LastStoreUrl { get; private set; }
|
|
|
|
/// <summary>게임을 끝낸다(서버 점검 안내의 「확인」 · 이용 제한 안내의 「종료」). 테스트 모드에서는 세기만 한다.</summary>
|
|
public static void Quit()
|
|
{
|
|
Quits++;
|
|
if (ServerConfig.Forced) return;
|
|
#if UNITY_EDITOR
|
|
UnityEditor.EditorApplication.isPlaying = false;
|
|
#else
|
|
Application.Quit();
|
|
#endif
|
|
}
|
|
|
|
/// <summary>스토어를 연다(업데이트 안내의 버튼). 테스트 모드에서는 주소만 적어 둔다.</summary>
|
|
public static void OpenStore(string url)
|
|
{
|
|
LastStoreUrl = url;
|
|
if (ServerConfig.Forced || string.IsNullOrEmpty(url)) return;
|
|
Application.OpenURL(url);
|
|
}
|
|
|
|
/// <summary>서버 연결 테스트 전용 — 씬을 열기 전에 부른다. 끝나면 ClearForce.</summary>
|
|
public static void ForceForTest(string url, int gameId)
|
|
{
|
|
ServerClient.ClearMemory(); // 테스트마다 새 계정으로 시작한다
|
|
ServerSync.Drop(); // 앞 테스트가 타이틀 씬에서 만든 일꾼(씬이 바뀌어도 남는다)을 치운다
|
|
FromTitle = false;
|
|
Quits = 0;
|
|
LastStoreUrl = null;
|
|
ServerConfig.ForceForTest(url, gameId);
|
|
Apply();
|
|
}
|
|
|
|
/// <summary>서버 연결 테스트 전용 — 켜면 테스트에서도 로그인 화면을 거친다(기본 = 화면 없이 게스트 자동 로그인). ClearForce 가 되돌린다.</summary>
|
|
public static bool LoginUi;
|
|
|
|
/// <summary>로그인 화면 없이 자동으로 로그인하는가(테스트 모드의 기본).</summary>
|
|
public static bool AutoLogin
|
|
{
|
|
get { return ServerConfig.Forced && !LoginUi; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// 타이틀부터 다시 시작한다(로그아웃 · 계정 삭제 · 다른 기기에서 접속해 세션이 끊김 · 기존 연동 계정으로 들어감) —
|
|
/// 타이틀 씬으로 돌아가 접속 일꾼이 새로 로그인하게 한다(저장한 증표가 없으면 타이틀 위에 로그인 화면).
|
|
/// 타이틀 씬을 거치지 않고 게임 씬을 바로 연 경우(개발 · 테스트)에는 그 씬을 다시 연다.
|
|
/// </summary>
|
|
public static void Restart()
|
|
{
|
|
ServerSync.Drop();
|
|
UnityEngine.SceneManagement.SceneManager.LoadScene(FromTitle ? BootScenes.Title : UnityEngine.SceneManagement.SceneManager.GetActiveScene().name);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 서버 연결 테스트 전용 — 켜면 접속할 때 기기 시간대를 보내지 않는다(시간대가 없는 기존 계정이 접속한 경우를 만든다). ClearForce 가 되돌린다.
|
|
/// </summary>
|
|
public static bool SkipSignupTimezone;
|
|
|
|
public static void ClearForce()
|
|
{
|
|
SkipSignupTimezone = false;
|
|
LoginUi = false;
|
|
FromTitle = false;
|
|
Quits = 0;
|
|
LastStoreUrl = null;
|
|
ServerClient.Intercept = null;
|
|
ServerSync.Drop();
|
|
ServerClient.ClearMemory();
|
|
ServerConfig.ClearForce();
|
|
Apply();
|
|
}
|
|
}
|
|
}
|