import { JsonAsset, sys } from "cc";

// 定义今天的数据类
export class LocalTodayData {
    private _todayData: TodayData;

    constructor() {
        let defaultData: TodayData = {
            lookVedionum: 0,
            isUnlockAll: false,
            UnLockAllTimes: 0
        }
        this._todayData = sys.localStorage.getItem("todayData") ? Object.assign(defaultData, JSON.parse(sys.localStorage.getItem("todayData"))) : defaultData
    }

    get todayData(): TodayData {
        return this._todayData;
    }

    set todayData(data: Partial<TodayData>) {
        Object.assign(this._todayData, data);
        this.saveTodayData();
    }

    // 获取用户数据
    getTodayData(): TodayData {
        return this._todayData;
    }

    // 设置用户数据
    setTodayData(data: Partial<TodayData>): void {
        Object.assign(this._todayData, data);
        this.saveTodayData();
    }

    // 保存用户数据到本地存储
    public saveTodayData(): void {
        sys.localStorage.setItem("todayData", JSON.stringify(this._todayData));
    }
}

export const Today = new LocalTodayData();

// 定义用户数据管理类
export class LocalDataMgr {
    private _userData: UserData;
    private _lixiantime: number;
    private _lixiantime2: string;
    constructor() {
        this.lixianTime2 = ""
        let defaultData: UserData = {
            unlockUnits: [],
            sound: true,
            music: true,
            openid: "demo",
            leveltime: 120
        }
        this._userData = sys.localStorage.getItem("userData") ? Object.assign(defaultData, JSON.parse(sys.localStorage.getItem("userData"))) : defaultData

        this.lixianTime = sys.localStorage.getItem("lixianTime") || 0
    }

    get lixianTime() {
        return this._lixiantime
    }

    set lixianTime(time: number) {
        this._lixiantime = time
        sys.localStorage.setItem("lixianTime", time)
    }

    get lixianTime2() {
        return this._lixiantime2
    }

    set lixianTime2(time: string) {
        this._lixiantime2 = time
        sys.localStorage.setItem("lixianTime2", time)
    }


    get userData(): UserData {
        return this._userData;
    }


    // 获取用户数据
    getUserData(): UserData {
        return this._userData;
    }

    // 设置用户数据
    setUserData(data: Partial<UserData>): void {
        Object.assign(this._userData, data)
        this.saveUserData();
    }

    // 保存用户数据到本地存储
    saveUserData(): void {
        sys.localStorage.setItem("userData", JSON.stringify(this._userData));
    }


    startgametime: number = 0;
    entergametime: number = 0
}

export const User = new LocalDataMgr();

export interface usercards {
    id: number,
    level: number,
    num: number
}

// 用户数据接口
export interface UserData {
    unlockUnits: Array<number>;
    sound: boolean;
    music: boolean;
    openid: string;
    leveltime: number;
}


export interface TodayData {
    lookVedionum: number;
    isUnlockAll: boolean;
    UnLockAllTimes: number;
}

export interface DifficutyData {
    difficutyCount: number;
    scales: Array<number>
}

export class UserDifficutyData {
    private _difficutyData: DifficutyData;

   createOrDeleteOtherScale() {
    const targetCount = this._difficutyData.difficutyCount;
    const currentScales = this._difficutyData.scales;
    const defaultScales = [1.18, 1.16, 1.14, 0.3976, 0.3690, 0.3029, 0.0667, 0.0766, 0.0531, 0.0716];

    if (currentScales.length > targetCount) {
        currentScales.splice(targetCount, currentScales.length - targetCount);
    }
    else if (currentScales.length < targetCount) {
        for (let i = currentScales.length; i < targetCount; i++) {
            let value: number;
            if (i < defaultScales.length) {
                value = defaultScales[i];
            } else {
                value = Math.random() * 0.035 + 0.04;
            }
            currentScales.push(value);
        }
    }

    for (let i = 0; i < targetCount; i++) {
        if (currentScales[i] === undefined || currentScales[i] === null) {
            if (i < defaultScales.length) {
                currentScales[i] = defaultScales[i];
            } else {
                currentScales[i] = Math.random() * 0.035 + 0.04;
            }
        }
    }

    // 保存修改后的数据
    this.saveDifficutyData();
}

    constructor() {
        const saved = sys.localStorage.getItem("difficutyData");
        this._difficutyData = saved 
            ? Object.assign({}, DEFAULT_DIFFICULTY_DATA, JSON.parse(saved))
            : {...DEFAULT_DIFFICULTY_DATA};
    }

    get difficutyData(): DifficutyData {
        return this._difficutyData;
    }

    set difficutyData(data: Partial<DifficutyData>) {
        Object.assign(this._difficutyData, data);
        this.saveDifficutyData();
    }

    // 获取难度数据
    getDifficutyData(): DifficutyData {
        return this._difficutyData;
    }

    // 设置难度数据
    setDifficutyData(data: Partial<DifficutyData>): void {
        Object.assign(this._difficutyData, data);
        this.saveDifficutyData();
    }

    // 保存用户数据到本地存储
    public saveDifficutyData(): void {
        sys.localStorage.setItem("difficutyData", JSON.stringify(this._difficutyData));
    }

    setDataToDefault() {
        this._difficutyData = {...DEFAULT_DIFFICULTY_DATA};
        
        this.createOrDeleteOtherScale();
    }
}

const DEFAULT_DIFFICULTY_DATA: DifficutyData = {
    difficutyCount: 10,
    scales: [1.18, 1.16, 1.14, 0.3976, 0.3690, 0.3029,
             0.0667, 0.0766, 0.0531, 0.0716]
};
export const Difficulty = new UserDifficutyData();

export class SkinData {
    singleSelect:string
    multiSelect:string
    selectedSkinList:Array<number>
    _lastSelectSpinePath:string = "prefab/spine/spine01"
}

export class UserSkinData {
     private _skinData: SkinData;
     private _selectSkins:string[] = []

    constructor() {
        let defaultData: SkinData = {
            singleSelect: "true",
            multiSelect: "false",
            selectedSkinList: [1],
            _lastSelectSpinePath:"prefab/spine/spine01",
        }
        this._skinData = sys.localStorage.getItem("skinData") ? Object.assign(defaultData, JSON.parse(sys.localStorage.getItem("skinData"))) : defaultData
        console.log(this._skinData)
    }

    getSelectSkinPath():string[]
    {
        let selectSkinsKeys = this._skinData.selectedSkinList
        this._selectSkins = []
        for(let key of selectSkinsKeys)
        {
            let skin = allSkinList[key]
            this._selectSkins.push(skin)
        }
        this._selectSkins = this._selectSkins.length > 0?this._selectSkins:[defaultSkin]
        return this._selectSkins
    }

    setSelectStatu(singleSelect:boolean)
    {
        this._skinData.singleSelect = singleSelect.toString()
        this._skinData.multiSelect = (!singleSelect).toString()
        this.saveSkinData()
    }

    setCurrentSelSingleSkin(key:number)
    {
        this._skinData._lastSelectSpinePath = allSkinList[key]
        this.saveSkinData()
    }

    setCurrentSelSingleSkinToDefault()
    {
        this._skinData._lastSelectSpinePath = defaultSkin
        this.saveSkinData()
    }

    get skinData(): SkinData {
        return this._skinData;
    }

    set skinData(data: Partial<SkinData>) {
        Object.assign(this._skinData, data);
        this.saveSkinData();
    }

    // 获取皮肤数据
    getSkinData(): SkinData {
        return this._skinData;
    }

    // 设置皮肤数据
    setSkinData(data: Partial<SkinData>): void {
        Object.assign(this._skinData, data);
        this.saveSkinData();
    }

    // 保存用户数据到本地存储
    public saveSkinData(): void {
        sys.localStorage.setItem("skinData", JSON.stringify(this._skinData));
    }

    addSelectSkin(key:number)
    {
        let index = this._skinData.selectedSkinList.indexOf(key)
        if(index == -1)
        {
            this._skinData.selectedSkinList.push(key)
        }
        this.setCurrentSelSingleSkin(key)
        this.saveSkinData()
    }

    removeSelectSkin(key:number)
    {
        let index = this._skinData.selectedSkinList.indexOf(key)
        if(index != -1)
        {
            this._skinData.selectedSkinList.splice(index,1)
        }
        this.setCurrentSelSingleSkinToDefault()

        this.saveSkinData()
    }

    removeAllSelectSkin()
    {
        this._skinData.selectedSkinList = [1]
        this.setCurrentSelSingleSkinToDefault()
        this.saveSkinData()
    }

    addAllSelectSkin()
    {
        this._skinData.selectedSkinList = []
        let allSkinkeys = getAllSkinKeys()
        for(let i = 0;i < allSkinkeys.length;i++)
        {
            this._skinData.selectedSkinList.push(allSkinkeys[i])
            this.setCurrentSelSingleSkin(allSkinkeys[i])
        }
        this.saveSkinData()
    }

    clearData()
    {
        let defaultData: SkinData = {
            singleSelect: "true",
            multiSelect: "false",
            selectedSkinList: [1],
            _lastSelectSpinePath:"prefab/spine/spine01",
        }
        this._skinData = defaultData
        this.saveSkinData()
    }
}

export const Skin = new UserSkinData();

export interface MapData {
    types:Array<string>
    selectedMaps:Array<number>
}

export class UserMapData {
     private _mapData: MapData;
     private _selectMaps:string[] = []

    constructor() {
        let defaultData: MapData = {
            types: imgTypeList,
            selectedMaps: []
        }
        this._mapData = sys.localStorage.getItem("mapData") ? Object.assign(defaultData, JSON.parse(sys.localStorage.getItem("mapData"))) : defaultData
    }

    get mapData(): MapData {
        return this._mapData;
    }

    set mapData(data: Partial<MapData>) {
        Object.assign(this._mapData, data);
        this.saveMapData();
    }

    getSelectMapPath():string[]
    {
        let selectMapKeys = this._mapData.selectedMaps
        this._selectMaps = []
        for(let key of selectMapKeys)
        {
            let map = allMapList[key]
            this._selectMaps.push(map.path)
        }
        this._selectMaps = this._selectMaps.length > 0?this._selectMaps:[defaultMap]
        return this._selectMaps
    }

    // 获取地图数据
    getMapData(): MapData {
        return this._mapData;
    }

    // 设置地图数据
    setMapData(data: Partial<MapData>): void {
        Object.assign(this._mapData, data);
        this.saveMapData();
    }

    // 保存用户数据到本地存储
    public saveMapData(): void {
        sys.localStorage.setItem("mapData", JSON.stringify(this._mapData));
    }
    clearData()
    {
        let defaultData: MapData = {
            types: imgTypeList,
            selectedMaps: []
        }
        this._mapData = defaultData
        this.saveMapData()
    }
    addSelectMap(key:number)
    {
        let index = this._mapData.selectedMaps.indexOf(key)
        if(index == -1)
        {
            this._mapData.selectedMaps.push(key)
        }
        this.saveMapData()
    }
    addSelectMap2(keys:number[])
    {
        for(let key of keys)
        {
            let index = this._mapData.selectedMaps.indexOf(key)
            if(index == -1)
            {
                this._mapData.selectedMaps.push(key)
            }
        }
        this.saveMapData()
    }

    removeSelectMap(key:number)
    {
        let index = this._mapData.selectedMaps.indexOf(key)
        if(index != -1)
        {
            this._mapData.selectedMaps.splice(index,1)
        }
        this.saveMapData()
    }

    removeAllSelectMap()
    {
        this._mapData.selectedMaps = []
        this.saveMapData()
    }

    addAllSelectMap()
    {
        this._mapData.selectedMaps = []
        let allMapkeys = getAllMapKeys()
        for(let i = 0;i < allMapkeys.length;i++)
        {
            this._mapData.selectedMaps.push(allMapkeys[i])
        }
        this.saveMapData()
    }
    getLastLevelMapKey(currentBgKey:number):number
    {
        if(this._mapData.selectedMaps.length == 0)
        {
            let curkeyIndex = getAllMapKeys().indexOf(currentBgKey)
            let result = curkeyIndex > 0?getAllMapKeys()[curkeyIndex - 1]:getAllMapKeys()[getAllMapKeys().length - 1]
            return result;
        }
        let index = this._mapData.selectedMaps.indexOf(currentBgKey)
        if(index > 0)
        {
            return this._mapData.selectedMaps[index - 1]
        }
        return this._mapData.selectedMaps[this._mapData.selectedMaps.length - 1]
    }
    getNextLevelMapKey(currentBgKey:number):number
    {
        if (this._mapData.selectedMaps.length == 0) {
            let curkeyIndex = getAllMapKeys().indexOf(currentBgKey)
            let result = curkeyIndex < getAllMapKeys().length - 1?getAllMapKeys()[curkeyIndex + 1]:getAllMapKeys()[0]
            return result;
        }
        let index = this._mapData.selectedMaps.indexOf(currentBgKey)
        if(index < this._mapData.selectedMaps.length - 1)
        {
            return this._mapData.selectedMaps[index + 1]
        }
        return this._mapData.selectedMaps[0]
    }
}

export const UserMap = new UserMapData()

export const defaultMap = "image/bg1"

export interface SuperFindData {
    title:string
    levelDesc:string
    imgPath:string
    currentBgKey:number
}

export class UserSuperFindData {
    private _superFindData: SuperFindData;

    constructor() {
        let defaultData: SuperFindData = {
            title: `找到${Difficulty.getDifficutyData().difficutyCount}个跳舞的小熊`,
            levelDesc: `超级找茬王-找小熊-第${1}关`,
            imgPath: `image/bg1`,
            currentBgKey:1
        }
        this._superFindData = sys.localStorage.getItem("superFindData") ? Object.assign(defaultData, JSON.parse(sys.localStorage.getItem("superFindData"))) : defaultData
    }
    get superFindData(): SuperFindData {
        return this._superFindData;
    }

    set superFindData(data: Partial<SuperFindData>) {
        Object.assign(this._superFindData, data);
        this.saveSuperFindData();
    }

    // 获取疯狂找茬数据
    getSuperFindData(): SuperFindData {
        return this._superFindData;
    }

    // 设置疯狂找茬数据
    setSuperFindData(data: Partial<SuperFindData>): void {
        Object.assign(this._superFindData, data);
        this.saveSuperFindData();
    }

    // 保存数据到本地存储
    public saveSuperFindData(): void {
        sys.localStorage.setItem("superFindData", JSON.stringify(this._superFindData));
    }

    clearData()
    {
        let defaultData: SuperFindData = {
            title: `找到${Difficulty.getDifficutyData().difficutyCount}个跳舞的小熊`,
            levelDesc: `超级找茬王-找小熊-第${1}关`,
            imgPath: `image/bg1`,
            currentBgKey:1
        }
        this._superFindData = defaultData
        this.saveSuperFindData()
    }
    
    lastLevel()
    {
        let lastKey = UserMap.getLastLevelMapKey(this._superFindData.currentBgKey)
        this._superFindData.currentBgKey = lastKey
        this.setTitle()
        this._superFindData.levelDesc = `超级找茬王-找小熊-第${lastKey}关`
        this._superFindData.imgPath = allMapList[lastKey].path
        this.saveSuperFindData()
    }

    nextLevel()
    {
        let nextKey = UserMap.getNextLevelMapKey(this._superFindData.currentBgKey)
        this._superFindData.currentBgKey = nextKey
        this.setTitle()
        this._superFindData.levelDesc = `超级找茬王-找小熊-第${nextKey}关`
        this._superFindData.imgPath = allMapList[nextKey].path
        this.saveSuperFindData()
    }

    setTitle()
    {
        this._superFindData.title = `找到${Difficulty.getDifficutyData().difficutyCount}个跳舞的小熊`
        console.log(this._superFindData.title)
        this.saveSuperFindData()
    }
}

export const SuperFind = new UserSuperFindData();

// export const canSelectedSkinList: { [key: number]: string } = {
//     //假设30个数据
//     1: "spine/hecha",
//     2: "spine/hecha",
//     3: "spine/hecha",
//     4: "spine/hecha",
//     5: "spine/hecha",
//     6: "spine/hecha",
//     7: "spine/hecha",
//     8: "spine/hecha",
//     9: "spine/hecha",
//     10: "spine/hecha",
//     11: "spine/hecha",
//     12: "spine/hecha",
//     13: "spine/hecha",
//     14: "spine/hecha",
//     15: "spine/hecha",
//     16: "spine/hecha",
//     17: "spine/hecha",
//     18: "spine/hecha",
//     19: "spine/hecha",
//     20: "spine/hecha",
//     21: "spine/hecha",
//     22: "spine/hecha",
//     23: "spine/hecha",
//     24: "spine/hecha",
//     25: "spine/hecha",
//     26: "spine/hecha",
//     27: "spine/hecha",
//     28: "spine/hecha",
//     29: "spine/hecha",
//     30: "spine/hecha",
// };

export const allSkinList: { [key: number]: string } = {
    //假设30个数据
    1: "prefab/spine/spine01",
    // 2: "prefab/spine/spine02",
    // 3: "prefab/spine/spine03",
    // 4: "prefab/spine/spine04",
    // 5: "prefab/spine/spine05",
    // 6: "prefab/spine/spine06",
    // 7: "prefab/spine/spine07",
    // 8: "prefab/spine/spine08",
    // 9: "prefab/spine/spine09",
    // 10: "prefab/spine/spine10",
    // 11: "prefab/spine/spine11",
    // 12: "prefab/spine/spine12",
    // 13: "prefab/spine/spine13",
    // 14: "prefab/spine/spine14",
    // 15: "prefab/spine/spine15",
    // 16: "prefab/spine/spine16",
    // 17: "prefab/spine/spine17",
    // 18: "prefab/spine/spine18",
    // 19: "prefab/spine/spine19",
    // 20: "prefab/spine/spine20",
    // 21: "prefab/spine/spine21",
    // 22: "prefab/spine/spine22",
    // 23: "prefab/spine/spine23",
    // 24: "prefab/spine/spine24",
    // 25: "prefab/spine/spine25",
    // 26: "prefab/spine/spine26",
    // 27: "prefab/spine/spine27",
    // 28: "prefab/spine/spine28",
    // 29: "prefab/spine/spine29",
    // 30: "prefab/spine/spine30",
};

export const defaultSkin = "prefab/spine/spine01"

export interface MapItemData {
    path: string;
    type: string;
}

export const imgTypeList = ["全部","爱心风景","古风美女","解压切东西","水果服小孩","物品人脸"]

export const allMapList: { [key: number]: MapItemData } = {

        1: { path: "image/bg1", type: "爱心风景" },
    2: { path: "image/bg2", type: "爱心风景" },
    3: { path: "image/bg3", type: "爱心风景" },
    4: { path: "image/bg4", type: "爱心风景" },
    5: { path: "image/bg5", type: "爱心风景" },
    6: { path: "image/bg6", type: "爱心风景" },
    7: { path: "image/bg7", type: "爱心风景" },
    8: { path: "image/bg8", type: "爱心风景" },
    9: { path: "image/bg9", type: "爱心风景" },
    10: { path: "image/bg10", type: "爱心风景" },
    11: { path: "image/bg11", type: "古风美女" },
    12: { path: "image/bg12", type: "古风美女" },
    13: { path: "image/bg13", type: "古风美女" },
    14: { path: "image/bg14", type: "古风美女" },
    15: { path: "image/bg15", type: "古风美女" },
    16: { path: "image/bg16", type: "古风美女" },
    17: { path: "image/bg17", type: "古风美女" },
    18: { path: "image/bg18", type: "古风美女" },
    19: { path: "image/bg19", type: "古风美女" },
    20: { path: "image/bg20", type: "古风美女" },
    21: { path: "image/bg21", type: "古风美女" },
    22: { path: "image/bg22", type: "古风美女" },
    23: { path: "image/bg23", type: "古风美女" },
    24: { path: "image/bg24", type: "古风美女" },
    25: { path: "image/bg25", type: "古风美女" },
    26: { path: "image/bg26", type: "古风美女" },
    27: { path: "image/bg27", type: "古风美女" },
    28: { path: "image/bg28", type: "古风美女" },
    29: { path: "image/bg29", type: "古风美女" },
    30: { path: "image/bg30", type: "古风美女" },
    31: { path: "image/bg31", type: "解压切东西" },
    32: { path: "image/bg32", type: "解压切东西" },
    33: { path: "image/bg33", type: "解压切东西" },
    34: { path: "image/bg34", type: "解压切东西" },
    35: { path: "image/bg35", type: "解压切东西" },
    36: { path: "image/bg36", type: "解压切东西" },
    37: { path: "image/bg37", type: "解压切东西" },
    38: { path: "image/bg38", type: "解压切东西" },
    39: { path: "image/bg39", type: "解压切东西" },
    40: { path: "image/bg40", type: "解压切东西" },
    41: { path: "image/bg41", type: "解压切东西" },
    42: { path: "image/bg42", type: "解压切东西" },
    43: { path: "image/bg43", type: "解压切东西" },
    44: { path: "image/bg44", type: "解压切东西" },
    45: { path: "image/bg45", type: "解压切东西" },
    46: { path: "image/bg46", type: "解压切东西" },
    47: { path: "image/bg47", type: "解压切东西" },
    48: { path: "image/bg48", type: "解压切东西" },
    49: { path: "image/bg49", type: "解压切东西" },
    50: { path: "image/bg50", type: "解压切东西" },
    51: { path: "image/bg51", type: "解压切东西" },
    52: { path: "image/bg52", type: "解压切东西" },
    53: { path: "image/bg53", type: "解压切东西" },
    54: { path: "image/bg54", type: "水果服小孩" },
    55: { path: "image/bg55", type: "水果服小孩" },
    56: { path: "image/bg56", type: "水果服小孩" },
    57: { path: "image/bg57", type: "水果服小孩" },
    58: { path: "image/bg58", type: "水果服小孩" },
    59: { path: "image/bg59", type: "水果服小孩" },
    60: { path: "image/bg60", type: "水果服小孩" },
    61: { path: "image/bg61", type: "水果服小孩" },
    62: { path: "image/bg62", type: "水果服小孩" },
    63: { path: "image/bg63", type: "水果服小孩" },
    64: { path: "image/bg64", type: "物品人脸" },
    65: { path: "image/bg65", type: "物品人脸" },
    66: { path: "image/bg66", type: "物品人脸" },
    67: { path: "image/bg67", type: "物品人脸" },
    68: { path: "image/bg68", type: "物品人脸" },
    69: { path: "image/bg69", type: "物品人脸" },
    70: { path: "image/bg70", type: "物品人脸" },
    71: { path: "image/bg71", type: "物品人脸" },
    72: { path: "image/bg72", type: "物品人脸" },
    73: { path: "image/bg73", type: "物品人脸" },
    74: { path: "image/bg74", type: "物品人脸" },
    75: { path: "image/bg75", type: "物品人脸" },
    76: { path: "image/bg76", type: "物品人脸" }
};

export function getOneTypeImgList(type:string)
{
    let list = []
    for(let key in allMapList)
    {
        if(allMapList[key].type == type)
        {
            list.push(allMapList[key])
        }
    }
    return list
}

export function getOneTypeImgKeyList(type:string)
{
    let list = []
    if(type == "全部")
    {
        UserMap.addAllSelectMap()
        return
    }
    for(let key in allMapList)
    {
        if(allMapList[key].type == type)
        {
            list.push(key)
        }
    }
    return list
}


/**
 * 获取 所有皮肤 中所有的键
 * @returns 包含所有键的数字数组
 */
export function getAllSkinKeys(): number[] {
    return Object.keys(allSkinList).map(Number);
}

/**
 * 获取 所有地图 中所有的键
 * @returns 包含所有键的数字数组
 */
export function getAllMapKeys(): number[] {
    return Object.keys(allMapList).map(Number);
}

export interface DanceData {
    spinePath: string[];
    scale: string[];
    danceObjsPos:vector2Pos[];
}

export interface vector2Pos {
    x: number;
    y: number;
}

export class UserDanceData {
    private _danceData: DanceData;

    constructor() {
        let obj = Skin.getSkinData().selectedSkinList[0]
        let defaultData: DanceData = {
            spinePath: [],
            scale: [],
            danceObjsPos: []
        }
        this._danceData = sys.localStorage.getItem("danceData") ? Object.assign(defaultData, JSON.parse(sys.localStorage.getItem("danceData"))) : defaultData
    }
    get danceData(): DanceData {
        return this._danceData;
    }

    set danceData(data: Partial<DanceData>) {
        Object.assign(this._danceData, data);
        this.saveDanceData();
    }
    // 保存数据到本地存储
    public saveDanceData(): void {
        sys.localStorage.setItem("danceData", JSON.stringify(this._danceData));
    }

    clearData()
    {
        let defaultData: DanceData = {
            spinePath: [],
            scale: [],
            danceObjsPos: []
        }
        this._danceData = defaultData
        this.saveDanceData()
    }
}

export const Dance = new UserDanceData();

export function clearSuperFindAllData()
{
    Dance.clearData()
    Skin.clearData()
    UserMap.clearData()
    SuperFind.clearData()
    Difficulty.setDataToDefault()
}