diff --git a/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/Attribute.java b/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/Attribute.java
index eb1c4e7..e1d787e 100644
--- a/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/Attribute.java
+++ b/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/Attribute.java
@@ -1,6 +1,71 @@
 package org.imesense.dynamicspawncontrol.technical.attributefactory;
 
-public class Attribute
+/**
+ *
+ * @param <T>
+ */
+public final class Attribute<T>
 {
+    /**
+     *
+     */
+    private final boolean multiKey;
 
+    /**
+     *
+     */
+    private final AttributeKey<T> key;
+
+    /**
+     *
+     * @param key
+     * @param multiKey
+     */
+    public Attribute(AttributeKey<T> key, boolean multiKey)
+    {
+        this.key = key;
+        this.multiKey = multiKey;
+    }
+
+    /**
+     *
+     * @param key
+     * @return
+     * @param <T>
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> Attribute<Object> create(AttributeKey<T> key)
+    {
+        return (Attribute<Object>) new Attribute<>(key, false);
+    }
+
+    /**
+     *
+     * @param key
+     * @return
+     * @param <T>
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> Attribute<Object> createMulti(AttributeKey<T> key)
+    {
+        return (Attribute<Object>) new Attribute<>(key, true);
+    }
+
+    /**
+     *
+     * @return
+     */
+    public AttributeKey<T> getKey()
+    {
+        return this.key;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public boolean isMulti()
+    {
+        return this.multiKey;
+    }
 }
diff --git a/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeKey.java b/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeKey.java
index 2a25b57..81bfb62 100644
--- a/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeKey.java
+++ b/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeKey.java
@@ -1,6 +1,42 @@
 package org.imesense.dynamicspawncontrol.technical.attributefactory;
 
-public class AttributeKey
+import javax.annotation.Nonnull;
+
+public final class AttributeKey<T>
 {
+    private final String name;
+
+    private final AttributeType<T> type;
+
+    public AttributeKey(@Nonnull AttributeType<T> type,
+                        @Nonnull String name)
+    {
+        this.type = type;
+        this.name = name;
+    }
+
+    @Nonnull
+    public static <T> AttributeKey<T> create(@Nonnull AttributeType<T> type,
+                                             @Nonnull String code)
+    {
+        return new AttributeKey<>(type, code);
+    }
+
+    @Nonnull
+    public AttributeType<T> getType()
+    {
+        return this.type;
+    }
+
+    @Nonnull
+    public String getName()
+    {
+        return this.name;
+    }
 
+    @Override
+    public String toString()
+    {
+        return "Key(" + this.name + ')';
+    }
 }
diff --git a/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeMap.java b/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeMap.java
index 1526c44..0748c96 100644
--- a/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeMap.java
+++ b/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeMap.java
@@ -1,6 +1,158 @@
 package org.imesense.dynamicspawncontrol.technical.attributefactory;
 
-public class AttributeMap
+import javax.annotation.Nonnull;
+import java.util.*;
+
+/**
+ *
+ * @param <T>
+ */
+public final class AttributeMap<T>
 {
+    /**
+     *
+     */
+    private final HashMap<AttributeKey<?>, Object> values = new HashMap<>();
+
+    /**
+     *
+     * @param key
+     * @return
+     */
+    public boolean has(@Nonnull AttributeKey<?> key)
+    {
+        return this.values.containsKey(key);
+    }
+
+    /**
+     *
+     * @param key
+     * @param value
+     */
+    public void set(@Nonnull AttributeKey<T> key, T value)
+    {
+        values.put(key, value);
+    }
+
+    /**
+     *
+     * @param key
+     * @param value
+     */
+    public void setNonnull(@Nonnull AttributeKey<T> key, T value)
+    {
+        if (value != null)
+        {
+            this.values.put(key, value);
+        }
+    }
+
+    /**
+     *
+     * @param key
+     * @return
+     */
+    @SuppressWarnings("unchecked")
+    public T get(@Nonnull AttributeKey<?> key)
+    {
+        return (T) this.values.get(key);
+    }
+
+    /**
+     *
+     * @param key
+     * @return
+     */
+    @SuppressWarnings("unchecked")
+    public Optional<T> getOptional(@Nonnull AttributeKey<T> key)
+    {
+        return Optional.ofNullable((T) this.values.get(key));
+    }
+
+    /**
+     *
+     * @param key
+     * @param value
+     */
+    @SuppressWarnings("unchecked")
+    public void addList(@Nonnull AttributeKey<?> key, T value)
+    {
+        if (!this.values.containsKey(key))
+        {
+            this.values.put(key, new ArrayList<>());
+        }
+
+        List<T> list = (List<T>) this.values.get(key);
+        list.add(value);
+    }
+
+    /**
+     *
+     * @param key
+     * @param value
+     */
+    @SuppressWarnings("unchecked")
+    public void addListNonnull(@Nonnull AttributeKey<T> key, T value)
+    {
+        if (value == null)
+        {
+            return;
+        }
+
+        if (!this.values.containsKey(key))
+        {
+            this.values.put(key, new ArrayList<>());
+        }
+
+        List<T> list = (List<T>) this.values.get(key);
+        list.add(value);
+    }
+
+    /**
+     *
+     * @param key
+     * @return
+     */
+    @SuppressWarnings("unchecked")
+    public List<String> getList(@Nonnull AttributeKey<?> key)
+    {
+        if (!this.values.containsKey(key))
+        {
+            return Collections.emptyList();
+        }
+
+        return (List<String>) this.values.get(key);
+    }
+
+    /**
+     *
+     * @param key
+     * @return
+     */
+    @SuppressWarnings("unchecked")
+    public List<Integer> getListI(@Nonnull AttributeKey<?> key)
+    {
+        if (!this.values.containsKey(key))
+        {
+            return Collections.emptyList();
+        }
+
+        return (List<Integer>) this.values.get(key);
+    }
+
+    /**
+     *
+     * @param key
+     * @return
+     */
+    @SuppressWarnings("unchecked")
+    public List<AttributeMap<String>> getListA(@Nonnull AttributeKey<?> key)
+    {
+        if (!this.values.containsKey(key))
+        {
+            return Collections.emptyList();
+        }
 
+        return (List<AttributeMap<String>>) this.values.get(key);
+    }
 }
diff --git a/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeMapFactory.java b/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeMapFactory.java
index c06e327..524ab0f 100644
--- a/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeMapFactory.java
+++ b/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeMapFactory.java
@@ -1,6 +1,121 @@
 package org.imesense.dynamicspawncontrol.technical.attributefactory;
 
-public class AttributeMapFactory
+import com.google.gson.*;
+import org.imesense.dynamicspawncontrol.technical.customlibrary.JsonServices;
+
+import java.util.*;
+import javax.annotation.Nonnull;
+import java.util.function.Function;
+
+/**
+ *
+ * @param <T>
+ */
+public final class AttributeMapFactory<T>
 {
+    /**
+     *
+     */
+    private final ArrayList<Attribute<T>> _attributes = new ArrayList<>();
+
+    /**
+     *
+     * @param attribute
+     * @return
+     */
+    public AttributeMapFactory<T> attribute(@Nonnull Attribute<T> attribute)
+    {
+        this._attributes.add(attribute);
+        return this;
+    }
+
+    /**
+     *
+     * @param element
+     * @return
+     */
+    @Nonnull
+    @SuppressWarnings("unchecked")
+    public AttributeMap<T> parse(@Nonnull JsonElement element)
+    {
+        AttributeMap<T> map = new AttributeMap<>();
+        JsonObject jsonObject = element.getAsJsonObject();
+
+        for (Attribute<T> attribute : _attributes)
+        {
+            AttributeKey<T> key = attribute.getKey();
+            AttributeType<T> type = key.getType();
+
+            if (attribute.isMulti())
+            {
+                Map<AttributeType<T>, Function<JsonElement, Object>> transformers = new HashMap<>();
+
+                transformers.put((AttributeType<T>)AttributeType.INTEGER, JsonElement::getAsInt);
+                transformers.put((AttributeType<T>)AttributeType.FLOAT, JsonElement::getAsFloat);
+                transformers.put((AttributeType<T>)AttributeType.BOOLEAN, JsonElement::getAsBoolean);
+                transformers.put((AttributeType<T>)AttributeType.STRING, JsonElement::getAsString);
+                transformers.put((AttributeType<T>)AttributeType.JSON, JsonElement::toString);
+
+                JsonServices.getElement(jsonObject, key.getName())
+                        .ifPresent(e ->
+                                JsonServices.asArrayOrSingle(e)
+                                        .map(transformers.getOrDefault(type, x -> "INVALID"))
+                                        .forEach(s -> map.addListNonnull(key, (T) s)));
+            }
+            else
+            {
+                if (type == AttributeType.INTEGER)
+                {
+                    map.setNonnull(key, (T) JsonServices.parseInt(jsonObject, key.getName()));
+                }
+                else if (type == AttributeType.FLOAT)
+                {
+                    map.setNonnull(key, (T) JsonServices.parseFloat(jsonObject, key.getName()));
+                }
+                else if (type == AttributeType.BOOLEAN)
+                {
+                    map.setNonnull(key, (T) JsonServices.parseBool(jsonObject, key.getName()));
+                }
+                else if (type == AttributeType.STRING)
+                {
+                    if (jsonObject.has(key.getName()))
+                    {
+                        map.setNonnull(key, (T)jsonObject.get(key.getName()).getAsString());
+                    }
+                }
+                else if (type == AttributeType.JSON)
+                {
+                    if (jsonObject.has(key.getName()))
+                    {
+                        JsonElement el = jsonObject.get(key.getName());
+
+                        if (el.isJsonObject())
+                        {
+                            JsonObject obj = el.getAsJsonObject();
+                            map.setNonnull(key, (T)obj.toString());
+                        }
+                        else if (el.isJsonPrimitive())
+                        {
+                            JsonPrimitive prim = el.getAsJsonPrimitive();
+
+                            if (prim.isString())
+                            {
+                                map.setNonnull(key, (T)prim.getAsString());
+                            }
+                            else if (prim.isNumber())
+                            {
+                                map.setNonnull(key, (T)("" + prim.getAsInt()));
+                            }
+                            else
+                            {
+                                throw new RuntimeException("Неверный тип для ключа '" + key.getName() + "'!");
+                            }
+                        }
+                    }
+                }
+            }
+        }
 
+        return map;
+    }
 }
diff --git a/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeType.java b/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeType.java
index 267ef16..60b78b1 100644
--- a/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeType.java
+++ b/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/attributefactory/AttributeType.java
@@ -1,6 +1,126 @@
 package org.imesense.dynamicspawncontrol.technical.attributefactory;
 
-public class AttributeType
+import javax.annotation.Nonnull;
+import java.util.List;
+
+/**
+ *
+ * @param <T>
+ */
+public final class AttributeType<T>
 {
-    
+    /**
+     *
+     */
+    public static final AttributeType<Long> LONG = create(Long.class);
+
+    /**
+     *
+     */
+    public static final AttributeType<Float> FLOAT = create(Float.class);
+
+    /**
+     *
+     */
+    public static final AttributeType<String> JSON = create(String.class);
+
+    /**
+     *
+     */
+    public static final AttributeType<Double> DOUBLE = create(Double.class);
+
+    /**
+     *
+     */
+    public static final AttributeType<String> STRING = create(String.class);
+
+    /**
+     *
+     */
+    public static final AttributeType<Boolean> BOOLEAN = create(Boolean.class);
+
+    /**
+     *
+     */
+    public static final AttributeType<Integer> INTEGER = create(Integer.class);
+
+    /**
+     *
+     */
+    public static final AttributeType<?> MAP = create(AttributeMap.class);
+
+    /**
+     *
+     */
+    public static final AttributeType<Object> OBJECT = new AttributeType<>(Object.class);
+
+    /**
+     *
+     */
+    private final Class<T> type;
+
+    /**
+     *
+     * @param type
+     */
+    private AttributeType(@Nonnull Class<T> type)
+    {
+        this.type = type;
+    }
+
+    /**
+     *
+     * @param type
+     * @return
+     * @param <T>
+     */
+    @Nonnull
+    @SuppressWarnings("unchecked")
+    public static <T> AttributeType<T> create(@Nonnull Class<? super T> type)
+    {
+        return new AttributeType<>((Class<T>) type);
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Nonnull
+    public Class<T> getType()
+    {
+        return this.type;
+    }
+
+    /**
+     *
+     * @param list
+     * @return
+     */
+    @Nonnull
+    public List<T> convert(@Nonnull List<T> list)
+    {
+        return list;
+    }
+
+    /**
+     *
+     * @param javaObject
+     * @return
+     */
+    @Nonnull
+    @SuppressWarnings("unchecked")
+    public T convert(Object javaObject)
+    {
+        return (T) javaObject;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public String toString()
+    {
+        return "Type(" + getType().getSimpleName() + ')';
+    }
 }
diff --git a/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/customlibrary/JsonServices.java b/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/customlibrary/JsonServices.java
new file mode 100644
index 0000000..cdb3953
--- /dev/null
+++ b/dynamicspawncontrol-1.12.2/src/main/java/org/imesense/dynamicspawncontrol/technical/customlibrary/JsonServices.java
@@ -0,0 +1,240 @@
+package org.imesense.dynamicspawncontrol.technical.customlibrary;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import org.apache.commons.lang3.tuple.Pair;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.BiFunction;
+import java.util.stream.Stream;
+
+/**
+ *
+ */
+public final class JsonServices
+{
+    /**
+     *
+     * @param element
+     * @param name
+     * @return
+     */
+    public static Optional<JsonElement> getElement(JsonObject element, String name)
+    {
+        JsonElement el = element.get(name);
+
+        if (el != null)
+        {
+            return Optional.of(el);
+        }
+        else
+        {
+            return Optional.empty();
+        }
+    }
+
+    /**
+     *
+     * @param jsonObject
+     * @param name
+     * @return
+     */
+    @Nullable
+    public static Float parseFloat(JsonObject jsonObject, String name)
+    {
+        if (jsonObject.has(name))
+        {
+            return jsonObject.get(name).getAsFloat();
+        }
+        else
+        {
+            return null;
+        }
+    }
+
+    /**
+     *
+     * @param jsonObject
+     * @param name
+     * @return
+     */
+    @Nullable
+    public static Integer parseInt(JsonObject jsonObject, String name)
+    {
+        if (jsonObject.has(name))
+        {
+            return jsonObject.get(name).getAsInt();
+        }
+        else
+        {
+            return null;
+        }
+    }
+
+    /**
+     *
+     * @param jsonObject
+     * @param name
+     * @return
+     */
+    @Nullable
+    public static Boolean parseBool(JsonObject jsonObject, String name)
+    {
+        if (jsonObject.has(name))
+        {
+            return jsonObject.get(name).getAsBoolean();
+        }
+        else
+        {
+            return null;
+        }
+    }
+
+    /**
+     *
+     * @param element
+     * @return
+     */
+    public static Stream<Pair<String, String>> asPairs(JsonElement element)
+    {
+        Stream.Builder<Pair<String, String>> builder = Stream.builder();
+
+        for (Map.Entry<String, JsonElement> entry : element.getAsJsonObject().entrySet())
+        {
+            builder.add(Pair.of(entry.getKey(), entry.getValue().getAsString()));
+        }
+
+        return builder.build();
+    }
+
+    /**
+     *
+     * @param element
+     * @return
+     */
+    public static Stream<JsonElement> asArrayOrSingle(JsonElement element)
+    {
+        if (element.isJsonArray())
+        {
+            Stream.Builder<JsonElement> builder = Stream.builder();
+
+            for (JsonElement el : element.getAsJsonArray())
+            {
+                builder.add(el);
+            }
+
+            return builder.build();
+        }
+        else
+        {
+            return Stream.of(element);
+        }
+    }
+
+    /**
+     *
+     * @param parent
+     * @param name
+     * @param pairs
+     */
+    public static void addPairs(JsonObject parent, String name, Map<String, String> pairs)
+    {
+        if (pairs != null)
+        {
+            JsonObject object = new JsonObject();
+
+            for (Map.Entry<String, String> entry : pairs.entrySet())
+            {
+                object.add(entry.getKey(), new JsonPrimitive(entry.getValue()));
+            }
+
+            parent.add(name, object);
+        }
+    }
+
+    /**
+     *
+     * @param parent
+     * @param name
+     * @param strings
+     */
+    public static void addArrayOrSingle(JsonObject parent, String name, Collection<String> strings)
+    {
+        if (strings != null)
+        {
+            if (strings.size() == 1)
+            {
+                parent.add(name, new JsonPrimitive(strings.iterator().next()));
+            }
+            else
+            {
+                JsonArray array = new JsonArray();
+
+                for (String value : strings)
+                {
+                    array.add(new JsonPrimitive(value));
+                }
+
+                parent.add(name, array);
+            }
+        }
+    }
+
+    /**
+     *
+     * @param parent
+     * @param name
+     * @param integers
+     */
+    public static void addIntArrayOrSingle(JsonObject parent, String name, Collection<Integer> integers)
+    {
+        if (integers != null)
+        {
+            if (integers.size() == 1)
+            {
+                parent.add(name, new JsonPrimitive(integers.iterator().next()));
+            }
+            else
+            {
+                JsonArray array = new JsonArray();
+
+                for (Integer value : integers)
+                {
+                    array.add(new JsonPrimitive(value));
+                }
+
+                parent.add(name, array);
+            }
+        }
+    }
+
+    /**
+     *
+     * @param jsonObject
+     * @param key
+     * @param defaultValue
+     * @param extractor
+     * @return
+     * @param <T>
+     */
+    public static <T> T getValueFromJson(JsonObject jsonObject, String key, T defaultValue, BiFunction<JsonElement, T, T> extractor)
+    {
+        Log.writeDataToLogFile(Log.TypeLog[0], "Read jsonObject: " + jsonObject);
+
+        if (jsonObject.has(key))
+        {
+            JsonElement element = jsonObject.get(key);
+            if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isNumber())
+            {
+                return extractor.apply(element, defaultValue);
+            }
+        }
+
+        return defaultValue;
+    }
+}