396 lines
9.9 KiB
Java
396 lines
9.9 KiB
Java
/*
|
|
* This file is part of the L2J Mobius project.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
package com.l2jmobius.xml;
|
|
|
|
import java.io.File;
|
|
import java.math.BigDecimal;
|
|
import java.nio.ByteBuffer;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import com.l2jmobius.L2ClientDat;
|
|
import com.l2jmobius.clientcryptor.crypt.DatCrypter;
|
|
import com.l2jmobius.config.ConfigDebug;
|
|
import com.l2jmobius.data.GameDataName;
|
|
import com.l2jmobius.util.ByteReader;
|
|
import com.l2jmobius.util.DebugUtil;
|
|
|
|
public class DescriptorReader
|
|
{
|
|
private static DescriptorReader _instance = new DescriptorReader();
|
|
final String eq = "=";
|
|
final String tab = "\t";
|
|
final String nl = System.getProperty("line.separator");
|
|
final String semi = ";";
|
|
final String lb = "[";
|
|
final String rb = "]";
|
|
|
|
public static DescriptorReader getInstance()
|
|
{
|
|
return _instance;
|
|
}
|
|
|
|
public String parseData(File currentFile, DatCrypter crypter, Descriptor desc, ByteBuffer data) throws Exception
|
|
{
|
|
String stringData;
|
|
if (desc.isRawData())
|
|
{
|
|
StringBuilder builder = new StringBuilder();
|
|
readVariables(currentFile, crypter, desc.getNodes().get(0), new HashMap<String, Variant>(), data, builder, true);
|
|
stringData = builder.toString();
|
|
}
|
|
else
|
|
{
|
|
stringData = this.parseData(currentFile, crypter, data, null, desc.getNodes(), 1, new HashMap<String, Variant>(), false, 0).trim();
|
|
}
|
|
if (desc.getFormat() != null)
|
|
{
|
|
stringData = desc.getFormat().decode(stringData);
|
|
}
|
|
int pos = desc.isSafePackage() ? data.position() + 13 : data.position();
|
|
if (data.limit() > pos)
|
|
{
|
|
L2ClientDat.addLogConsole("Unpacked not full " + data.position() + "/" + data.limit() + " diff: " + (data.limit() - pos), true);
|
|
}
|
|
return stringData;
|
|
}
|
|
|
|
private String parseData(File currentFile, DatCrypter crypter, ByteBuffer data, ParamNode lastNode, List<ParamNode> nodes, int cycleSize, Map<String, Variant> vars, boolean isNameHidden, int cycleNameLevel) throws Exception
|
|
{
|
|
if (cycleSize > 0)
|
|
{
|
|
StringBuilder out = new StringBuilder();
|
|
for (int i = 0; i < cycleSize; ++i)
|
|
{
|
|
boolean isAddCycleName = !isNameHidden && (lastNode != null) && lastNode.getEntityType().isCycle();
|
|
if (isAddCycleName)
|
|
{
|
|
for (int k = 0; k < cycleNameLevel; ++k)
|
|
{
|
|
out.append("\t");
|
|
}
|
|
out.append(lastNode.getName().concat("_begin"));
|
|
++cycleNameLevel;
|
|
}
|
|
int nodeSize = nodes.size();
|
|
int nNode = 0;
|
|
for (ParamNode n : nodes)
|
|
{
|
|
if (n.isIterator())
|
|
{
|
|
continue;
|
|
}
|
|
++nNode;
|
|
}
|
|
if (isNameHidden && (nNode > 1))
|
|
{
|
|
out.append("{");
|
|
}
|
|
for (int j = 0; j < nodeSize; ++j)
|
|
{
|
|
ParamNode node = nodes.get(j);
|
|
if (node.getEntityType().isIf())
|
|
{
|
|
Variant var = vars.get(node.getParamIf());
|
|
if ((var == null) || !var.toString().equalsIgnoreCase(node.getValIf()))
|
|
{
|
|
continue;
|
|
}
|
|
out.append(this.parseData(currentFile, crypter, data, null, node.getSubNodes(), 1, vars, isNameHidden, cycleNameLevel));
|
|
continue;
|
|
}
|
|
if (!(node.isIterator() || node.getEntityType().isConstant() || isNameHidden || (!node.getEntityType().isWrapper() && !node.isNameHidden())))
|
|
{
|
|
out.append("\t").append(node.getName()).append("=");
|
|
}
|
|
if (node.getEntityType().isWrapper())
|
|
{
|
|
out.append(this.parseData(currentFile, crypter, data, null, node.getSubNodes(), 1, vars, true, cycleNameLevel));
|
|
}
|
|
else if (node.getEntityType().isCycle())
|
|
{
|
|
int size;
|
|
if (node.getSize() >= 0)
|
|
{
|
|
size = node.getSize();
|
|
}
|
|
else
|
|
{
|
|
Variant var = vars.get(node.getCycleName());
|
|
if (var.isInt())
|
|
{
|
|
size = var.getInt();
|
|
}
|
|
else if (var.isShort())
|
|
{
|
|
size = var.getShort();
|
|
}
|
|
else
|
|
{
|
|
throw new Exception("Wrong cycle variable format for cycle: " + node.getName() + " iterator: " + node.getCycleName());
|
|
}
|
|
}
|
|
if (node.isNameHidden())
|
|
{
|
|
out.append("{");
|
|
}
|
|
out.append(this.parseData(currentFile, crypter, data, node, node.getSubNodes(), size, vars, node.isNameHidden(), cycleNameLevel));
|
|
if (node.isNameHidden())
|
|
{
|
|
out.append("}");
|
|
}
|
|
}
|
|
else if (node.getEntityType().isConstant())
|
|
{
|
|
out.append(node.getName().replace("\\t", "\t").replace("\\r\\n", "\r\n"));
|
|
}
|
|
else if (node.getEntityType().isVariable())
|
|
{
|
|
readVariables(currentFile, crypter, node, vars, data, out, false);
|
|
}
|
|
if (!node.isIterator() && !node.getEntityType().isConstant() && isNameHidden && (j != (nodeSize - 1)))
|
|
{
|
|
out.append(";");
|
|
}
|
|
if (!vars.containsKey(node.getName()))
|
|
{
|
|
continue;
|
|
}
|
|
DebugUtil.debugPos(data.position(), node.getName(), vars.get(node.getName()));
|
|
}
|
|
if (isNameHidden)
|
|
{
|
|
if (nNode > 1)
|
|
{
|
|
out.append("}");
|
|
}
|
|
if (i < (cycleSize - 1))
|
|
{
|
|
out.append(";");
|
|
}
|
|
}
|
|
if (!isAddCycleName)
|
|
{
|
|
continue;
|
|
}
|
|
if (out.charAt(out.length() - 1) != '\n')
|
|
{
|
|
out.append("\t");
|
|
}
|
|
out.append(lastNode.getName()).append("_end\r\n");
|
|
--cycleNameLevel;
|
|
}
|
|
return out.toString();
|
|
}
|
|
return "";
|
|
}
|
|
|
|
private void readVariables(File currentFile, DatCrypter crypter, ParamNode node, Map<String, Variant> vars, ByteBuffer data, StringBuilder out, boolean isRaw) throws Exception
|
|
{
|
|
switch (node.getType())
|
|
{
|
|
case UCHAR:
|
|
{
|
|
short value = (byte) ByteReader.readChar(data);
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(value);
|
|
}
|
|
vars.put(node.getName(), new Variant(value, Short.class));
|
|
break;
|
|
}
|
|
case UBYTE:
|
|
{
|
|
int value = ByteReader.readUByte(data);
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(value);
|
|
}
|
|
vars.put(node.getName(), new Variant(value, Integer.class));
|
|
break;
|
|
}
|
|
case SHORT:
|
|
{
|
|
short value = ByteReader.readShort(data);
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(value);
|
|
}
|
|
vars.put(node.getName(), new Variant(value, Short.class));
|
|
break;
|
|
}
|
|
case USHORT:
|
|
{
|
|
int value = ByteReader.readShort(data) & 65535;
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(value);
|
|
}
|
|
vars.put(node.getName(), new Variant(value, Integer.class));
|
|
break;
|
|
}
|
|
case UINT:
|
|
{
|
|
int value = ByteReader.readUInt(data);
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(value);
|
|
}
|
|
vars.put(node.getName(), new Variant(value, Integer.class));
|
|
break;
|
|
}
|
|
case INT:
|
|
{
|
|
int value = ByteReader.readInt(data);
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(value);
|
|
}
|
|
vars.put(node.getName(), new Variant(value, Integer.class));
|
|
break;
|
|
}
|
|
case CNTR:
|
|
{
|
|
int value = ByteReader.readCompactInt(data);
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(value);
|
|
}
|
|
vars.put(node.getName(), new Variant(value, Integer.class));
|
|
break;
|
|
}
|
|
case UNICODE:
|
|
{
|
|
String str = ByteReader.readUtfString(data, isRaw);
|
|
if (isRaw)
|
|
{
|
|
out.append(str);
|
|
break;
|
|
}
|
|
if (!node.isIterator())
|
|
{
|
|
out.append("[").append(str).append("]");
|
|
}
|
|
vars.put(node.getName(), new Variant(str, String.class));
|
|
break;
|
|
}
|
|
case ASCF:
|
|
{
|
|
String str = ByteReader.readString(data, isRaw);
|
|
if (isRaw)
|
|
{
|
|
out.append(str);
|
|
break;
|
|
}
|
|
if (!node.isIterator())
|
|
{
|
|
out.append("[").append(str).append("]");
|
|
}
|
|
vars.put(node.getName(), new Variant(str, String.class));
|
|
break;
|
|
}
|
|
case DOUBLE:
|
|
{
|
|
double value = ByteReader.readDouble(data);
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(new BigDecimal(Double.toString(value)).toPlainString());
|
|
}
|
|
vars.put(node.getName(), new Variant(value, Double.class));
|
|
break;
|
|
}
|
|
case FLOAT:
|
|
{
|
|
float value = ByteReader.readFloat(data);
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(value);
|
|
}
|
|
vars.put(node.getName(), new Variant(Float.valueOf(value), Float.class));
|
|
break;
|
|
}
|
|
case LONG:
|
|
{
|
|
long value = ByteReader.readLong(data);
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(value);
|
|
}
|
|
vars.put(node.getName(), new Variant(value, Long.class));
|
|
break;
|
|
}
|
|
case RGBA:
|
|
{
|
|
String value = ByteReader.readRGBA(data);
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(value);
|
|
}
|
|
vars.put(node.getName(), new Variant(value, String.class));
|
|
break;
|
|
}
|
|
case RGB:
|
|
{
|
|
String value = ByteReader.readRGB(data);
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(value);
|
|
}
|
|
vars.put(node.getName(), new Variant(value, String.class));
|
|
break;
|
|
}
|
|
case HEX:
|
|
{
|
|
int value = ByteReader.readUByte(data);
|
|
if (!node.isIterator())
|
|
{
|
|
String hex = Integer.toHexString(value).toUpperCase();
|
|
if (hex.length() == 1)
|
|
{
|
|
hex = "0" + hex;
|
|
}
|
|
out.append(hex);
|
|
}
|
|
vars.put(node.getName(), new Variant(value, Integer.class));
|
|
break;
|
|
}
|
|
case MAP_INT:
|
|
{
|
|
int index = ByteReader.readUInt(data);
|
|
if (ConfigDebug.DAT_REPLACEMENT_NAMES)
|
|
{
|
|
String paramName = GameDataName.getInstance().getString(currentFile, crypter, index);
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(paramName);
|
|
}
|
|
vars.put(node.getName(), new Variant(paramName, String.class));
|
|
break;
|
|
}
|
|
if (!node.isIterator())
|
|
{
|
|
out.append(index);
|
|
}
|
|
vars.put(node.getName(), new Variant(index, Integer.class));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|