const localStorageUtil = {
STORAGE_KEYS: {
GAME_SETTINGS: 'chainReactionSettings',
HISTORY_RECORDS: 'chainReactionHistory',
},
loadGameSettings() {
try {
const settingsStr = localStorage.getItem(this.STORAGE_KEYS.GAME_SETTINGS);
if (!settingsStr) {
return {
speed: 0.5,
flashEnabled: true,
assistEnabled: false,
selectedScore: true,
assistPredictGlobal: false
};
}
const parsedSettings = JSON.parse(settingsStr);
return {
speed: parsedSettings.speed ? parsedSettings.speed : 0.5,
flashEnabled: parsedSettings.flashEnabled ? parsedSettings.flashEnabled : true,
assistEnabled: parsedSettings.assistEnabled ? parsedSettings.assistEnabled : false,
selectedScore: parsedSettings.selectedScore ? parsedSettings.selectedScore : true,
assistPredictGlobal: parsedSettings.assistPredictGlobal ? parsedSettings.assistPredictGlobal : false
};
} catch (error) {
return {
speed: 0.5,
flashEnabled: true,
assistEnabled: false,
selectedScore: true,
assistPredictGlobal: false
};
}
},
saveGameSettings(settings) {
try {
const validSettings = {
speed: settings.speed === 0.5 || settings.speed === 0.25 ? settings.speed : 0.5,
flashEnabled: typeof settings.flashEnabled === 'boolean' ? settings.flashEnabled : true,
assistEnabled: typeof settings.assistEnabled === 'boolean' ? settings.assistEnabled : false,
selectedScore: typeof settings.selectedScore === 'boolean' ? settings.selectedScore : true,
assistPredictGlobal: typeof settings.assistPredictGlobal === 'boolean' ? settings
.assistPredictGlobal : false
};
localStorage.setItem(
this.STORAGE_KEYS.GAME_SETTINGS,
JSON.stringify(validSettings)
);
return true;
} catch (error) {
return false;
}
},
getHistoryRecords() {
try {
const historyStr = localStorage.getItem(this.STORAGE_KEYS.HISTORY_RECORDS);
if (!historyStr) return [];
let historyRecords = []
try {
historyRecords = this._parseDataAfterLoad(historyStr);
if (!Array.isArray(historyRecords)) throw new Error('记录格式非数组');
historyRecords = historyRecords.map(item => {
const {
$index,
...rest
} = item;
return rest;
});
} catch (e) {
const oldRecords = JSON.parse(historyStr);
if (!Array.isArray(oldRecords)) return [];
historyRecords = oldRecords.map(item => {
const {
$index,
...rest
} = item;
return rest;
});
const savedStr = this._processDataBeforeSave(historyRecords);
localStorage.setItem(this.STORAGE_KEYS.HISTORY_RECORDS, savedStr);
}
return historyRecords.map((record, index) => ({
...record,
$index: index
}));
} catch (error) {
return null;
}
},
saveHistoryRecord(newRecord) {
try {
if (!newRecord.time || !newRecord.records || !Array.isArray(newRecord.records)) {
return false;
}
let historyRecords = this.getHistoryRecords().map(item => {
const {
$index,
...rest
} = item;
return rest;
});
const {
isMatched,
updatedHistory
} = this._checkRecordMatch(historyRecords, newRecord);
historyRecords = isMatched ? updatedHistory : [...historyRecords, newRecord];
const recordsBySeed = {};
historyRecords.forEach(record => {
const seed = record.time;
if (!recordsBySeed[seed]) recordsBySeed[seed] = [];
recordsBySeed[seed].push(record);
});
Object.keys(recordsBySeed).forEach(seed => {
const uniqueRecords = Array.from(
new Map(recordsBySeed[seed].map(r => [`${seed}_${r.score}`, r])).values()
);
recordsBySeed[seed] = uniqueRecords
.sort((a, b) => b.score - a.score)
.slice(0, 3);
});
const seedLevelRecords = [];
Object.values(recordsBySeed).forEach(seedRecords => {
seedLevelRecords.push(...seedRecords);
});
const uniqueAllRecords = Array.from(
new Map(historyRecords.map(r => [`${r.time}_${r.score}`, r])).values()
);
const top20GlobalRecords = uniqueAllRecords
.sort((a, b) => b.score - a.score)
.slice(0, 20);
const finalRecordsMap = new Map();
seedLevelRecords.forEach(record => {
const key = `${record.time}_${record.score}`;
if (!finalRecordsMap.has(key)) finalRecordsMap.set(key, record);
});
top20GlobalRecords.forEach(record => {
const key = `${record.time}_${record.score}`;
if (!finalRecordsMap.has(key)) finalRecordsMap.set(key, record);
});
const finalRecords = Array.from(finalRecordsMap.values())
.sort((a, b) => b.score - a.score);
const savedStr = this._processDataBeforeSave(finalRecords);
localStorage.setItem(this.STORAGE_KEYS.HISTORY_RECORDS, savedStr);
return true;
} catch (error) {
return false;
}
},
deleteHistoryRecord($index) {
try {
let historyRecords = this.getHistoryRecords().map(item => {
const {
$index,
...rest
} = item;
return rest;
});
if ($index < 0 || $index >= historyRecords.length) {
return false;
}
historyRecords.splice($index, 1);
localStorage.setItem(
this.STORAGE_KEYS.HISTORY_RECORDS,
JSON.stringify(historyRecords)
);
return true;
} catch (error) {
return false;
}
},
clearAllHistoryRecords() {
try {
localStorage.removeItem(this.STORAGE_KEYS.HISTORY_RECORDS);
return true;
} catch (error) {
return false;
}
},
exportStorageData() {
if (!window.key) return '';
try {
const rawData = localStorage.getItem(this.STORAGE_KEYS.HISTORY_RECORDS);
if (!rawData) return '';
const isCiphertext = rawData.startsWith('0_') || rawData.startsWith('1_');
let processedData = '';
if (!isCiphertext) {
const originalData = JSON.parse(rawData);
const encryptedStr = this._processDataBeforeSave(originalData);
processedData = this._compressData(encryptedStr);
} else {
const prefix = rawData.slice(0, 2);
if (prefix === '0_') {
const base64Data = rawData.slice(2);
const decodedStr = decodeURIComponent(escape(atob(base64Data)));
const decryptedStr = this._xorDecrypt(decodedStr, 123456780);
const originalData = JSON.parse(decryptedStr);
const encryptedStr = this._processDataBeforeSave(originalData);
processedData = this._compressData(encryptedStr);
} else if (prefix === '1_') {
processedData = this._compressData(rawData);
}
}
return processedData;
} catch (error) {
return '';
}
},
mergeCiphertextToHistory(ciphertext) {
if (!window.key) return false;
try {
let decompressedCiphertext = this._decompressData(ciphertext);
if (!decompressedCiphertext) return false;
if (!decompressedCiphertext.startsWith('1_')) return false;
const base64Data = decompressedCiphertext.slice(2);
const decodedStr = decodeURIComponent(escape(atob(base64Data)));
const decryptedStr = this._xorDecrypt(decodedStr, window.key);
const newRecords = JSON.parse(decryptedStr);
if (!Array.isArray(newRecords) || newRecords.length === 0) return false;
let existingRecords = this.getHistoryRecords().map(item => {
const {
$index,
...rest
} = item;
return rest;
});
newRecords.forEach(newRecord => {
if (!newRecord.time || !newRecord.records || !Array.isArray(newRecord.records)) {
return false;
}
const {
isMatched,
updatedHistory
} = this._checkRecordMatch(existingRecords, newRecord);
existingRecords = isMatched ? updatedHistory : [...existingRecords, newRecord];
const recordsBySeed = {};
existingRecords.forEach(record => {
const seed = record.time;
if (!recordsBySeed[seed]) recordsBySeed[seed] = [];
recordsBySeed[seed].push(record);
});
Object.keys(recordsBySeed).forEach(seed => {
const uniqueRecords = Array.from(
new Map(recordsBySeed[seed].map(r => [`${seed}_${r.score}`, r])).values()
);
recordsBySeed[seed] = uniqueRecords
.sort((a, b) => b.score - a.score)
.slice(0, 3);
});
const seedLevelRecords = [];
Object.values(recordsBySeed).forEach(seedRecords => {
seedLevelRecords.push(...seedRecords);
});
const uniqueAllRecords = Array.from(
new Map(existingRecords.map(r => [`${r.time}_${r.score}`, r])).values()
);
const top20GlobalRecords = uniqueAllRecords
.sort((a, b) => b.score - a.score)
.slice(0, 20);
const finalRecordsMap = new Map();
seedLevelRecords.forEach(record => {
const key = `${record.time}_${record.score}`;
if (!finalRecordsMap.has(key)) finalRecordsMap.set(key, record);
});
top20GlobalRecords.forEach(record => {
const key = `${record.time}_${record.score}`;
if (!finalRecordsMap.has(key)) finalRecordsMap.set(key, record);
});
existingRecords = Array.from(finalRecordsMap.values())
.sort((a, b) => b.score - a.score);
});
const savedStr = this._processDataBeforeSave(existingRecords);
localStorage.setItem(this.STORAGE_KEYS.HISTORY_RECORDS, savedStr);
return true;
} catch (error) {
return false;
}
},
_checkRecordMatch(historyRecords, newRecord) {
const sameSeedRecords = historyRecords.filter(item => item.time === newRecord.time);
if (sameSeedRecords.length === 0) {
return {
isMatched: false,
updatedHistory: historyRecords
};
}
for (let i = 0; i < sameSeedRecords.length; i++) {
const historyItem = sameSeedRecords[i];
const historyIndex = historyRecords.indexOf(historyItem);
if (this._checkPrefixMatch(historyItem.records, newRecord.records)) {
if (newRecord.records.length >= historyItem.records.length) {
historyRecords[historyIndex] = newRecord;
}
return {
isMatched: true,
updatedHistory: historyRecords
};
}
}
return {
isMatched: false,
updatedHistory: historyRecords
};
},
_checkPrefixMatch(arr1, arr2) {
const minLength = Math.min(arr1.length, arr2.length);
for (let i = 0; i < minLength; i++) {
if (arr1[i] !== arr2[i]) return false;
}
return true;
},
_xorEncrypt(data, key = 1234567890) {
let encrypted = [];
for (let i = 0; i < data.length; i++) {
const charCode = data.charCodeAt(i) ^ key;
encrypted.push(String.fromCharCode(charCode));
}
return encrypted.join('');
},
_xorDecrypt(encryptedData, key) {
return this._xorEncrypt(encryptedData, key);
},
_processDataBeforeSave(data) {
const jsonStr = JSON.stringify(data);
const encryptedStr = this._xorEncrypt(jsonStr, window.key ? window.key : 123456780);
return (window.key ? '1_' : '0_') + btoa(unescape(encodeURIComponent(encryptedStr)));
},
_parseDataAfterLoad(savedStr) {
try {
const prefix = savedStr.slice(0, 2);
const base64Data = savedStr.slice(2);
let decryptKey;
if (prefix === '1_') {
decryptKey = window.key ? window.key : 123456780;
} else if (prefix === '0_') {
decryptKey = 123456780;
} else {
throw new Error('无效的密钥标识前缀');
}
const decodedStr = decodeURIComponent(escape(atob(base64Data)));
const decryptedStr = this._xorDecrypt(decodedStr, decryptKey);
return JSON.parse(decryptedStr);
} catch (error) {
return null;
}
},
_compressData(rawData) {
try {
const uint8Array = new TextEncoder().encode(rawData);
const compressedUint8 = pako.deflate(uint8Array, {
level: 9
});
return btoa(String.fromCharCode(...compressedUint8));
} catch (error) {
return '';
}
},
_decompressData(compressedBase64) {
try {
const compressedUint8 = new Uint8Array(
atob(compressedBase64)
.split('')
.map(char => char.charCodeAt(0))
);
const decompressedUint8 = pako.inflate(compressedUint8);
return new TextDecoder().decode(decompressedUint8);
} catch (error) {
return '';
}
},
};
window.localStorageUtil = localStorageUtil;