游戏出海全攻略：从本土化到全球发行的制胜之道

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// 北美市场本地化配置
const naMarketConfig = {
  pricing: {
    tier1: 0.99,    // 基础档位
    tier2: 4.99,
    tier3: 9.99,
    tier4: 19.99,
    tier5: 49.99
  },
  events: {
    thanksgiving: {
      name: "Thanksgiving Festival",
      startDate: "2024-11-28",
      endDate: "2024-12-02",
      discounts: 0.3
    },
    blackFriday: {
      name: "Black Friday Special",
      startDate: "2024-11-29",
      endDate: "2024-12-01",
      discounts: 0.5
    },
    christmas: {
      name: "Winter Holiday",
      startDate: "2024-12-20",
      endDate: "2025-01-03",
      discounts: 0.25
    }
  },
  features: {
    englishVoice: true,
    textSize: "normal",  // 老年用户友好
    autoPlay: true,     // 休闲玩家需求
    crossSave: true     // 多平台同步
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// GDPR合规实现
class GDPRCompliance {
  constructor() {
    this.consentData = {};
    this.privacySettings = {
      analytics: false,
      advertising: false,
      crashReporting: true,
      performance: false
    };
  }

  // 显示隐私政策
  showPrivacyDialog() {
    return new Promise((resolve) => {
      const dialog = {
        title: this.getLocalizedText('privacy.title'),
        content: this.getLocalizedText('privacy.content'),
        buttons: [
          {
            text: this.getLocalizedText('privacy.accept_all'),
            action: () => this.acceptAllConsents()
          },
          {
            text: this.getLocalizedText('privacy.customize'),
            action: () => this.showCustomizeDialog()
          },
          {
            text: this.getLocalizedText('privacy.reject'),
            action: () => this.rejectAllConsents()
          }
        ]
      };

      this.showDialog(dialog, resolve);
    });
  }

  // 获取本地化文本
  getLocalizedText(key) {
    const texts = {
      'en': {
        'privacy.title': 'Privacy & Data',
        'privacy.content': 'We use cookies and data to...',
        'privacy.accept_all': 'Accept All',
        'privacy.customize': 'Customize',
        'privacy.reject': 'Reject'
      },
      'de': {
        'privacy.title': 'Datenschutz',
        'privacy.content': 'Wir verwenden Cookies...',
        'privacy.accept_all': 'Alle akzeptieren',
        'privacy.customize': 'Anpassen',
        'privacy.reject': 'Ablehnen'
      }
    };

    const locale = this.getUserLocale();
    return texts[locale]?.[key] || texts['en'][key];
  }

  // 数据处理前检查
  checkConsent(dataType) {
    return this.privacySettings[dataType] || this.isEssentialData(dataType);
  }

  // 数据删除请求处理
  handleDataDeletionRequest(userId) {
    return new Promise(async (resolve) => {
      try {
        // 删除用户数据
        await this.deleteUserData(userId);

        // 生成删除报告
        const report = await this.generateDeletionReport(userId);

        // 通知用户
        this.notifyDeletionComplete(userId);

        resolve({ success: true, report });
      } catch (error) {
        resolve({ success: false, error: error.message });
      }
    });
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// 日韩市场本地化
const jpkrConfig = {
  jp: {
    language: 'ja',
    textDirection: 'ltr',
    currency: 'JPY',
    dateFormat: 'YYYY/MM/DD',
    features: {
      voicePack: true,           // 声优文化
      gachaSystem: true,         // 抽卡机制
      idolSystem: true,          // 偶像元素
      seasonalEvents: true       // 季节活动
    },
    cultural: {
      avoidNumber4: true,        // 避讳数字4
      cherryBlossom: true,       // 樱花元素
      shrineVisit: true,         // 神社场景
      schoolSetting: true        // 校园背景
    }
  },
  kr: {
    language: 'ko',
    currency: 'KRW',
    features: {
      rankingSystem: true,       // 排行榜系统
      pvpArena: true,            // PvP竞技场
      guildSystem: true,         // 公会系统
      esportsIntegration: true   // 电竞元素
    },
    monetization: {
      battlePass: true,          // 通行证
      cosmeticItems: true,       // 外观道具
      convenienceItems: true     // 便利道具
    }
  }
};

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182

// 国际化管理器
class I18nManager {
  constructor() {
    this.currentLanguage = 'en';
    this.fallbackLanguage = 'en';
    this.translations = new Map();
    this.loadedLanguages = new Set();
    this.pluralRules = new Map();
  }

  // 初始化语言包
  async init(language = 'en') {
    await this.loadLanguage(language);
    await this.loadLanguage(this.fallbackLanguage);
    this.setLanguage(language);
    this.initPluralRules();
  }

  // 加载语言包
  async loadLanguage(language) {
    if (this.loadedLanguages.has(language)) {
      return;
    }

    try {
      const translations = await this.fetchTranslations(language);
      this.translations.set(language, translations);
      this.loadedLanguages.add(language);
    } catch (error) {
      console.error(`Failed to load language ${language}:`, error);
    }
  }

  // 获取翻译文件
  async fetchTranslations(language) {
    const response = await fetch(`./locales/${language}.json`);
    return await response.json();
  }

  // 设置当前语言
  setLanguage(language) {
    if (this.loadedLanguages.has(language)) {
      this.currentLanguage = language;
      this.updateUI();
      this.saveLanguagePreference(language);
    }
  }

  // 获取翻译文本
  t(key, params = {}) {
    const translation = this.getTranslation(key, this.currentLanguage) ||
                       this.getTranslation(key, this.fallbackLanguage) ||
                       key;

    // 处理参数替换
    return this.interpolate(translation, params);
  }

  // 获取特定语言的翻译
  getTranslation(key, language) {
    const translations = this.translations.get(language);
    if (!translations) return null;

    // 支持嵌套key如 'menu.settings.audio'
    const keys = key.split('.');
    let result = translations;

    for (const k of keys) {
      result = result?.[k];
      if (result === undefined) return null;
    }

    return result;
  }

  // 复数形式处理
  tn(key, count, params = {}) {
    const rule = this.getPluralRule(count);
    const pluralKey = `${key}.${rule}`;

    params.count = count;
    return this.t(pluralKey, params);
  }

  // 获取复数规则
  getPluralRule(count) {
    const rule = this.pluralRules.get(this.currentLanguage);
    return rule ? rule(count) : 'other';
  }

  // 初始化复数规则
  initPluralRules() {
    // 英语复数规则
    this.pluralRules.set('en', (n) => n === 1 ? 'one' : 'other');

    // 中文无复数
    this.pluralRules.set('zh', () => 'other');

    // 日语复数规则
    this.pluralRules.set('ja', () => 'other');

    // 法语复数规则
    this.pluralRules.set('fr', (n) => n >= 0 && n < 2 ? 'one' : 'other');
  }

  // 参数插值
  interpolate(text, params) {
    return text.replace(/\{\{(\w+)\}\}/g, (match, key) => {
      return params[key] !== undefined ? params[key] : match;
    });
  }

  // 更新UI文本
  updateUI() {
    // 更新所有带有data-i18n属性的元素
    const elements = document.querySelectorAll('[data-i18n]');
    elements.forEach(element => {
      const key = element.getAttribute('data-i18n');
      const text = this.t(key);

      if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
        element.placeholder = text;
      } else {
        element.textContent = text;
      }
    });
  }

  // 保存语言偏好
  saveLanguagePreference(language) {
    localStorage.setItem('preferredLanguage', language);
  }

  // 获取保存的语言
  getSavedLanguage() {
    return localStorage.getItem('preferredLanguage') ||
           navigator.language.split('-')[0] ||
           'en';
  }

  // 动态加载字体
  async loadFontForLanguage(language) {
    const fontConfig = {
      'ar': {
        family: 'Noto Sans Arabic',
        url: 'https://fonts.googleapis.com/css2?family=Noto+Sans+Arabic:wght@400;700&display=swap'
      },
      'ja': {
        family: 'Noto Sans JP',
        url: 'https://fonts.googleapis.com/css2?family=Noto+Sans+JP:wght@400;700&display=swap'
      },
      'ko': {
        family: 'Noto Sans KR',
        url: 'https://fonts.googleapis.com/css2?family=Noto+Sans+KR:wght@400;700&display=swap'
      },
      'th': {
        family: 'Noto Sans Thai',
        url: 'https://fonts.googleapis.com/css2?family=Noto+Sans+Thai:wght@400;700&display=swap'
      }
    };

    const config = fontConfig[language];
    if (config) {
      const link = document.createElement('link');
      link.href = config.url;
      link.rel = 'stylesheet';
      document.head.appendChild(link);

      // 等待字体加载
      await document.fonts.load(`16px ${config.family}`);
    }
  }

  // 处理文本方向
  setTextDirection() {
    const rtlLanguages = ['ar', 'he', 'fa'];
    const isRTL = rtlLanguages.includes(this.currentLanguage);

    document.documentElement.dir = isRTL ? 'rtl' : 'ltr';
    document.body.classList.toggle('rtl', isRTL);
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

// 资源本地化系统
class AssetLocalizationManager {
  constructor() {
    this.localizedAssets = new Map();
    this.assetCache = new Map();
    this.currentRegion = 'global';
  }

  // 根据地区加载资源
  async loadLocalizedAsset(assetType, assetName, region) {
    const cacheKey = `${region}:${assetType}:${assetName}`;

    if (this.assetCache.has(cacheKey)) {
      return this.assetCache.get(cacheKey);
    }

    try {
      // 尝试加载地区特定资源
      let assetUrl = this.getLocalizedAssetUrl(assetType, assetName, region);
      let asset = await this.loadAsset(assetUrl);

      // 如果地区特定资源不存在，使用全局资源
      if (!asset && region !== 'global') {
        assetUrl = this.getLocalizedAssetUrl(assetType, assetName, 'global');
        asset = await this.loadAsset(assetUrl);
      }

      if (asset) {
        this.assetCache.set(cacheKey, asset);
        return asset;
      }
    } catch (error) {
      console.error(`Failed to load localized asset: ${assetName}`, error);
    }

    return null;
  }

  // 获取本地化资源URL
  getLocalizedAssetUrl(assetType, assetName, region) {
    const baseUrl = './assets';
    const regionFolder = region !== 'global' ? `/${region}` : '';

    switch (assetType) {
      case 'image':
        return `${baseUrl}/images${regionFolder}/${assetName}`;
      case 'audio':
        return `${baseUrl}/audio${regionFolder}/${assetName}`;
      case 'video':
        return `${baseUrl}/video${regionFolder}/${assetName}`;
      case 'ui':
        return `${baseUrl}/ui${regionFolder}/${assetName}`;
      default:
        return `${baseUrl}${regionFolder}/${assetName}`;
    }
  }

  // 加载资源
  async loadAsset(url) {
    if (url.endsWith('.json')) {
      const response = await fetch(url);
      return await response.json();
    } else if (url.match(/\.(jpg|jpeg|png|gif|webp)$/)) {
      return new Promise((resolve, reject) => {
        const img = new Image();
        img.onload = () => resolve(img);
        img.onerror = reject;
        img.src = url;
      });
    } else if (url.match(/\.(mp3|wav|ogg)$/)) {
      return new Promise((resolve, reject) => {
        const audio = new Audio();
        audio.oncanplaythrough = () => resolve(audio);
        audio.onerror = reject;
        audio.src = url;
      });
    }
  }

  // 预加载地区特定资源
  async preloadRegionalAssets(region, assetList) {
    const promises = assetList.map(async (asset) => {
      return {
        type: asset.type,
        name: asset.name,
        data: await this.loadLocalizedAsset(asset.type, asset.name, region)
      };
    });

    const results = await Promise.allSettled(promises);
    return results.filter(r => r.status === 'fulfilled').map(r => r.value);
  }

  // 清理缓存
  clearCache() {
    this.assetCache.clear();
  }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231

// 文化适配管理器
class CulturalAdaptationManager {
  constructor() {
    this.culturalConfigs = new Map();
    this.currentCulture = 'default';
    this.initCulturalConfigs();
  }

  // 初始化文化配置
  initCulturalConfigs() {
    // 中东地区配置
    this.culturalConfigs.set('middle-east', {
      colors: {
        primary: '#2D5F8C',        // 深蓝色，代表稳重
        secondary: '#D4AF37',      // 金色，象征繁荣
        danger: '#DC143C',         // 红色，注意使用
        success: '#228B22'         // 绿色
      },
      imagery: {
        avoid: ['pigs', 'alcohol', 'revealing clothing'],
        prefer: ['geometric', 'calligraphy', 'architecture']
      },
      ui: {
        textDirection: 'rtl',
        fontFamily: 'Noto Sans Arabic',
        roundedCorners: false,    // 偏好方正设计
        minimalIcons: true         // 避免复杂图标
      },
      content: {
        genderRepresentation: 'separate',
        religiousSensitivity: 'high',
        familyValues: 'conservative'
      }
    });

    // 东亚地区配置
    this.culturalConfigs.set('east-asia', {
      colors: {
        primary: '#E60012',        // 中国红
        secondary: '#FFD700',      // 金色
        danger: '#FF0000',
        success: '#00C853'
      },
      imagery: {
        avoid: ['skulls', 'excessive violence'],
        prefer: ['dragons', 'nature', 'cute characters']
      },
      ui: {
        textDirection: 'ltr',
        fontFamily: 'Noto Sans CJK',
        denseLayout: true,         // 信息密度高
        cuteElements: true         // 可爱化元素
      },
      content: {
        ageRating: 'strict',
        violence: 'moderate',
        socialHarmony: 'important'
      }
    });

    // 欧美地区配置
    this.culturalConfigs.set('western', {
      colors: {
        primary: '#0078D4',        // 微软蓝
        secondary: '#50E3C2',
        danger: '#FF4444',
        success: '#4CAF50'
      },
      imagery: {
        avoid: [],
        prefer: ['realistic', 'diverse', 'modern']
      },
      ui: {
        textDirection: 'ltr',
        fontFamily: 'Roboto, Arial',
        cleanMinimal: true,
        highContrast: true
      },
      content: {
        diversity: 'important',
        individualism: 'valued',
        directCommunication: 'preferred'
      }
    });
  }

  // 应用文化适配
  applyCulturalAdaptation(culture) {
    const config = this.culturalConfigs.get(culture);
    if (!config) return;

    this.currentCulture = culture;

    // 应用颜色主题
    this.applyColorTheme(config.colors);

    // 应用UI调整
    this.applyUIAdjustments(config.ui);

    // 应用内容过滤
    this.applyContentFilters(config.content);
  }

  // 应用颜色主题
  applyColorTheme(colors) {
    const root = document.documentElement;
    root.style.setProperty('--primary-color', colors.primary);
    root.style.setProperty('--secondary-color', colors.secondary);
    root.style.setProperty('--danger-color', colors.danger);
    root.style.setProperty('--success-color', colors.success);
  }

  // 应用UI调整
  applyUIAdjustments(ui) {
    const body = document.body;

    // 设置文本方向
    body.style.direction = ui.textDirection;

    // 设置字体
    if (ui.fontFamily) {
      body.style.fontFamily = ui.fontFamily;
    }

    // 添加文化CSS类
    body.classList.add(`culture-${this.currentCulture}`);

    // 调整间距和布局
    if (ui.denseLayout) {
      body.classList.add('dense-layout');
    }

    if (ui.roundedCorners === false) {
      body.classList.add('square-corners');
    }
  }

  // 内容过滤
  filterContent(content, type) {
    const config = this.culturalConfigs.get(this.currentCulture);
    if (!config || !config.content) return content;

    switch (type) {
      case 'image':
        return this.filterImage(content, config.imagery);
      case 'text':
        return this.filterText(content, config.content);
      case 'audio':
        return this.filterAudio(content, config.content);
      default:
        return content;
    }
  }

  // 图片过滤
  filterImage(imageUrl, imageryConfig) {
    // 实现图片内容过滤逻辑
    // 可以使用AI图像识别API检测敏感内容
    return imageUrl;
  }

  // 文本过滤
  filterText(text, contentConfig) {
    let filteredText = text;

    // 根据文化敏感性过滤内容
    if (contentConfig.religiousSensitivity === 'high') {
      // 移除宗教相关敏感词汇
      filteredText = this.removeSensitiveContent(filteredText);
    }

    return filteredText;
  }

  // 获取本地化日期格式
  getLocalizedDateFormat() {
    const formats = {
      'middle-east': 'DD/MM/YYYY',
      'east-asia': 'YYYY/MM/DD',
      'western': 'MM/DD/YYYY',
      'european': 'DD.MM.YYYY'
    };

    return formats[this.currentCulture] || 'YYYY-MM-DD';
  }

  // 获取本地化数字格式
  formatNumber(number, type = 'decimal') {
    const formatters = {
      'middle-east': new Intl.NumberFormat('ar-SA'),
      'east-asia': new Intl.NumberFormat('zh-CN'),
      'western': new Intl.NumberFormat('en-US'),
      'european': new Intl.NumberFormat('de-DE')
    };

    const formatter = formatters[this.currentCulture] ||
                     new Intl.NumberFormat('en-US');

    switch (type) {
      case 'currency':
        return formatter.format(number);
      case 'percent':
        return formatter.format(number / 100) + '%';
      default:
        return formatter.format(number);
    }
  }

  // 获取文化特定的节日列表
  getCulturalHolidays() {
    const holidays = {
      'middle-east': [
        { name: 'Eid al-Fitr', date: '2024-04-10', type: 'major' },
        { name: 'Eid al-Adha', date: '2024-06-17', type: 'major' },
        { name: 'Ramadan Start', date: '2024-03-11', type: 'major' }
      ],
      'east-asia': [
        { name: 'Chinese New Year', date: '2024-02-10', type: 'major' },
        { name: 'Golden Week', date: '2024-04-29', type: 'major' },
        { name: 'Mid-Autumn Festival', date: '2024-09-17', type: 'minor' }
      ],
      'western': [
        { name: 'Christmas', date: '2024-12-25', type: 'major' },
        { name: 'Easter', date: '2024-03-31', type: 'major' },
        { name: 'Halloween', date: '2024-10-31', type: 'minor' }
      ]
    };

    return holidays[this.currentCulture] || [];
  }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218

// 渠道管理器
class ChannelManager {
  constructor() {
    this.channels = new Map();
    this.channelMetrics = new Map();
    this.initChannels();
  }

  // 初始化渠道配置
  initChannels() {
    // Google Play
    this.channels.set('google-play', {
      name: 'Google Play Store',
      platform: 'android',
      regions: ['global'],
      features: {
        inAppPurchase: true,
        subscriptions: true,
        seasonalPromotions: true,
        preRegistration: true
      },
      optimization: {
        aso: true,
        featuredPlacement: true,
        localPricing: true,
        betaTesting: true
      },
      costs: {
        developerFee: 25,
        revenueShare: 0.30
      }
    });

    // App Store
    this.channels.set('app-store', {
      name: 'Apple App Store',
      platform: 'ios',
      regions: ['global'],
      features: {
        inAppPurchase: true,
        subscriptions: true,
        appClips: true,
        arcade: false
      },
      optimization: {
        aso: true,
        editorialPlacement: true,
        searchAds: true,
        productPage: true
      },
      costs: {
        developerFee: 99,
        revenueShare: 0.30
      }
    });

    // Steam
    this.channels.set('steam', {
      name: 'Steam',
      platform: 'pc',
      regions: ['global'],
      features: {
        dlc: true,
        workshop: true,
        cards: true,
        achievements: true
      },
      optimization: {
        discoveryQueue: true,
        seasonalSales: true,
        communityFeatures: true,
        earlyAccess: true
      },
      costs: {
        submissionFee: 100,
        revenueShare: { 0.30: 1000000, 0.25: 50000000, 0.20: Infinity }
      }
    });

    // Nintendo eShop
    this.channels.set('eshop', {
      name: 'Nintendo eShop',
      platform: 'switch',
      regions: ['americas', 'europe', 'asia'],
      features: {
        demoVersions: true,
        discounts: true,
        goldPoints: true,
        multiplayer: true
      },
      optimization: {
        featuredBanners: true,
        eshopSales: true,
        socialMediaIntegration: true
      },
      costs: {
        developerProgram: 500,
        revenueShare: 0.30
      }
    });
  }

  // 获取推荐渠道
  getRecommendedChannels(targetPlatform, targetRegion, gameType) {
    const recommendations = [];

    this.channels.forEach((channel, channelKey) => {
      if (channel.platform === targetPlatform || targetPlatform === 'all') {
        if (channel.regions.includes('global') || channel.regions.includes(targetRegion)) {
          recommendations.push({
            id: channelKey,
            name: channel.name,
            matchScore: this.calculateMatchScore(channel, gameType)
          });
        }
      }
    });

    return recommendations.sort((a, b) => b.matchScore - a.matchScore);
  }

  // 计算渠道匹配度
  calculateMatchScore(channel, gameType) {
    let score = 50; // 基础分数

    // 根据游戏类型调整分数
    if (gameType === 'casual' && channel.features?.seasonalPromotions) {
      score += 20;
    }
    if (gameType === 'indie' && channel.platform === 'steam') {
      score += 30;
    }
    if (gameType === 'mobile' && (channel.platform === 'android' || channel.platform === 'ios')) {
      score += 25;
    }

    return score;
  }

  // 渠道发布检查清单
  getPublishingChecklist(channelKey) {
    const channel = this.channels.get(channelKey);
    if (!channel) return [];

    const checklist = [
      {
        category: 'legal',
        items: [
          { task: '隐私政策', required: true },
          { task: '服务条款', required: true },
          { task: '版权声明', required: true },
          { task: '地区法规符合', required: true }
        ]
      },
      {
        category: 'technical',
        items: [
          { task: '应用签名', required: true },
          { task: '权限声明', required: true },
          { task: '崩溃报告', required: false },
          { task: '性能优化', required: false }
        ]
      },
      {
        category: 'content',
        items: [
          { task: '本地化完成', required: true },
          { task: '截图和视频', required: true },
          { task: '描述文案', required: true },
          { task: '关键词优化', required: false }
        ]
      },
      {
        category: 'monetization',
        items: [
          { task: '定价策略', required: true },
          { task: '内购配置', required: false },
          { task: '广告集成', required: false },
          { task: '订阅设置', required: false }
        ]
      }
    ];

    return checklist;
  }

  // 渠道收益分析
  analyzeChannelRevenue(channelKey, metrics) {
    const channel = this.channels.get(channelKey);
    if (!channel) return null;

    const revenue = metrics.revenue || 0;
    const downloads = metrics.downloads || 0;
    const revenueShare = channel.costs.revenueShare;

    // 计算净收益
    let netRevenue = revenue;
    if (typeof revenueShare === 'number') {
      netRevenue = revenue * (1 - revenueShare);
    } else if (typeof revenueShare === 'object') {
      // 阶梯式分成
      for (const [share, threshold] of Object.entries(revenueShare)) {
        if (revenue <= threshold) {
          netRevenue = revenue * (1 - parseFloat(share));
          break;
        }
      }
    }

    return {
      grossRevenue: revenue,
      netRevenue,
      channelFee: revenue - netRevenue,
      arpd: downloads > 0 ? revenue / downloads : 0,
      profitMargin: revenue > 0 ? (netRevenue / revenue) * 100 : 0
    };
  }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

// 用户获取管理器
class UserAcquisitionManager {
  constructor() {
    this.campaigns = new Map();
    this.metrics = new Map();
    this.attributionModel = 'last_click';
  }

  // 创建营销活动
  createCampaign(config) {
    const campaign = {
      id: this.generateCampaignId(),
      name: config.name,
      type: config.type, // 'cpi', 'cpa', 'cpm', 'organic'
      platform: config.platform,
      region: config.region,
      budget: config.budget,
      targeting: config.targeting,
      creative: config.creative,
      startDate: config.startDate,
      endDate: config.endDate,
      status: 'active',
      metrics: {
        impressions: 0,
        clicks: 0,
        installs: 0,
        cost: 0,
        revenue: 0,
        roas: 0
      }
    };

    this.campaigns.set(campaign.id, campaign);
    return campaign;
  }

  // 获取用户来源分析
  getUserSourceAnalysis(timeRange = '30d') {
    const sources = {
      organic: { users: 0, revenue: 0, retention: [] },
      paid_social: { users: 0, revenue: 0, retention: [] },
      paid_search: { users: 0, revenue: 0, retention: [] },
      influencer: { users: 0, revenue: 0, retention: [] },
      referral: { users: 0, revenue: 0, retention: [] }
    };

    // 分析各渠道数据
    this.metrics.forEach((userMetrics, userId) => {
      const source = userMetrics.acquisitionSource;
      if (sources[source]) {
        sources[source].users++;
        sources[source].revenue += userMetrics.ltv || 0;
        sources[source].retention.push(userMetrics.retention || 0);
      }
    });

    // 计算平均值
    Object.keys(sources).forEach(source => {
      const retentionData = sources[source].retention;
      sources[source].avgRetention = retentionData.length > 0 ?
        retentionData.reduce((a, b) => a + b, 0) / retentionData.length : 0;
    });

    return sources;
  }

  // A/B测试广告素材
  async testAdCreatives(campaignId, creatives) {
    const results = [];

    for (const creative of creatives) {
      const testResult = await this.runAdTest(campaignId, creative);
      results.push({
        creative: creative,
        cpm: testResult.cpm,
        ctr: testResult.ctr,
        cpi: testResult.cpi,
        roas: testResult.roas,
        significance: testResult.significance
      });
    }

    // 排序并推荐最佳素材
    return results.sort((a, b) => b.roas - a.roas);
  }

  // 运行广告测试
  async runAdTest(campaignId, creative) {
    // 实现A/B测试逻辑
    // 返回测试指标
    return {
      cpm: 2.5,
      ctr: 0.015,
      cpi: 1.2,
      roas: 2.8,
      significance: 0.95
    };
  }

  // 计算LTV/CAC比率
  calculateLTVCACRatio() {
    let totalLTV = 0;
    let totalCAC = 0;
    let userCount = 0;

    this.metrics.forEach((metrics) => {
      if (metrics.ltv && metrics.cac) {
        totalLTV += metrics.ltv;
        totalCAC += metrics.cac;
        userCount++;
      }
    });

    if (userCount === 0) return 0;

    const avgLTV = totalLTV / userCount;
    const avgCAC = totalCAC / userCount;

    return avgLTV / avgCAC;
  }

  // 生成用户获取报告
  generateAcquisitionReport(timeRange = '7d') {
    const report = {
      period: timeRange,
      totalUsers: 0,
      totalCost: 0,
      totalRevenue: 0,
      avgCAC: 0,
      avgLTV: 0,
      ltvCACRatio: this.calculateLTVCACRatio(),
      topChannels: [],
      recommendations: []
    };

    // 统计数据
    this.campaigns.forEach((campaign) => {
      if (this.isCampaignInPeriod(campaign, timeRange)) {
        report.totalUsers += campaign.metrics.installs;
        report.totalCost += campaign.metrics.cost;
        report.totalRevenue += campaign.metrics.revenue;
      }
    });

    // 计算平均值
    if (report.totalUsers > 0) {
      report.avgCAC = report.totalCost / report.totalUsers;
      report.avgLTV = report.totalRevenue / report.totalUsers;
    }

    // 生成建议
    report.recommendations = this.generateRecommendations(report);

    return report;
  }

  // 生成优化建议
  generateRecommendations(report) {
    const recommendations = [];

    if (report.ltvCACRatio < 1) {
      recommendations.push({
        type: 'warning',
        message: 'LTV/CAC比率低于1，需要优化用户获取策略',
        actions: ['提高用户留存', '优化广告素材', '调整目标受众']
      });
    }

    if (report.avgCAC > report.avgLTV * 0.3) {
      recommendations.push({
        type: 'info',
        message: '获客成本偏高，建议优化投放渠道',
        actions: ['测试新渠道', '优化投放时段', '改进落地页']
      });
    }

    return recommendations;
  }

  // 生成活动ID
  generateCampaignId() {
    return 'camp_' + Date.now().toString(36) + Math.random().toString(36).substr(2);
  }

  // 检查活动是否在指定时间范围内
  isCampaignInPeriod(campaign, timeRange) {
    // 实现时间范围检查逻辑
    return true;
  }
}