diff --git a/include/core/events.h b/include/core/events.h
index bdf9d5a2..265ec541 100644
--- a/include/core/events.h
+++ b/include/core/events.h
@@ -186,9 +186,9 @@ public:
     void setIdName(QString newIdName) { this->idName = newIdName; }
     QString getIdName() const { return this->idName; }
 
-    static QString eventGroupToString(Event::Group group);
-    static QString eventTypeToString(Event::Type type);
-    static Event::Type eventTypeFromString(QString type);
+    static QString groupToString(Event::Group group);
+    static QString typeToString(Event::Type type);
+    static Event::Type typeFromString(QString type);
     static void clearIcons();
     static void setIcons();
 
diff --git a/include/project.h b/include/project.h
index f3a1093b..97b9a698 100644
--- a/include/project.h
+++ b/include/project.h
@@ -157,6 +157,7 @@ public:
 
     void initTopLevelMapFields();
     bool readMapJson(const QString &mapName, QJsonDocument * out);
+    bool loadMapEvent(Map *map, const QJsonObject &json, Event::Type defaultType = Event::Type::None);
     bool loadMapData(Map*);
     bool readMapLayouts();
     Layout *loadLayout(QString layoutId);
diff --git a/src/core/events.cpp b/src/core/events.cpp
index 87421035..648fb760 100644
--- a/src/core/events.cpp
+++ b/src/core/events.cpp
@@ -75,70 +75,36 @@ void Event::modify() {
     this->map->modify();
 }
 
-QString Event::eventGroupToString(Event::Group group) {
-    switch (group) {
-    case Event::Group::Object:
-        return "Object";
-    case Event::Group::Warp:
-        return "Warp";
-    case Event::Group::Coord:
-        return "Trigger";
-    case Event::Group::Bg:
-        return "BG";
-    case Event::Group::Heal:
-        return "Heal Location";
-    default:
-        return "";
-    }
+const QMap<Event::Group, QString> groupToStringMap = {
+    {Event::Group::Object, "Object"},
+    {Event::Group::Warp, "Warp"},
+    {Event::Group::Coord, "Trigger"},
+    {Event::Group::Bg, "BG"},
+    {Event::Group::Heal, "Heal Location"},
+};
+
+QString Event::groupToString(Event::Group group) {
+    return groupToStringMap.value(group);
 }
 
-QString Event::eventTypeToString(Event::Type type) {
-    switch (type) {
-    case Event::Type::Object:
-        return "event_object";
-    case Event::Type::CloneObject:
-        return "event_clone_object";
-    case Event::Type::Warp:
-        return "event_warp";
-    case Event::Type::Trigger:
-        return "event_trigger";
-    case Event::Type::WeatherTrigger:
-        return "event_weather_trigger";
-    case Event::Type::Sign:
-        return "event_sign";
-    case Event::Type::HiddenItem:
-        return "event_hidden_item";
-    case Event::Type::SecretBase:
-        return "event_secret_base";
-    case Event::Type::HealLocation:
-        return "event_heal_location";
-    default:
-        return "";
-    }
+const QMap<Event::Type, QString> typeToStringMap = {
+    {Event::Type::Object, "object"},
+    {Event::Type::CloneObject, "clone_object"},
+    {Event::Type::Warp, "warp"},
+    {Event::Type::Trigger, "trigger"},
+    {Event::Type::WeatherTrigger, "weather"},
+    {Event::Type::Sign, "sign"},
+    {Event::Type::HiddenItem, "hidden_item"},
+    {Event::Type::SecretBase, "secret_base"},
+    {Event::Type::HealLocation, "heal_location"},
+};
+
+QString Event::typeToString(Event::Type type) {
+    return typeToStringMap.value(type);
 }
 
-Event::Type Event::eventTypeFromString(QString type) {
-    if (type == "event_object") {
-        return Event::Type::Object;
-    } else if (type == "event_clone_object") {
-        return Event::Type::CloneObject;
-    } else if (type == "event_warp") {
-        return Event::Type::Warp;
-    } else if (type == "event_trigger") {
-        return Event::Type::Trigger;
-    } else if (type == "event_weather_trigger") {
-        return Event::Type::WeatherTrigger;
-    } else if (type == "event_sign") {
-        return Event::Type::Sign;
-    } else if (type == "event_hidden_item") {
-        return Event::Type::HiddenItem;
-    } else if (type == "event_secret_base") {
-        return Event::Type::SecretBase;
-    } else if (type == "event_heal_location") {
-        return Event::Type::HealLocation;
-    } else {
-        return Event::Type::None;
-    }
+Event::Type Event::typeFromString(QString type) {
+    return typeToStringMap.key(type, Event::Type::None);
 }
 
 void Event::loadPixmap(Project *) {
diff --git a/src/editor.cpp b/src/editor.cpp
index 6a2e0c20..f654b805 100644
--- a/src/editor.cpp
+++ b/src/editor.cpp
@@ -2092,7 +2092,7 @@ void Editor::duplicateSelectedEvents() {
         Event *original = selected_events->at(i)->event;
         Event::Type eventType = original->getEventType();
         if (eventLimitReached(eventType)) {
-            logWarn(QString("Skipping duplication, the map limit for events of type '%1' has been reached.").arg(Event::eventTypeToString(eventType)));
+            logWarn(QString("Skipping duplication, the map limit for events of type '%1' has been reached.").arg(Event::typeToString(eventType)));
             continue;
         }
         Event *duplicate = original->duplicate();
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index a38b3bd0..785c77af 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -1039,7 +1039,7 @@ void MainWindow::openWarpMap(QString map_name, int event_id, Event::Group event_
         }
     }
     // Can still warp to this map, but can't select the specified event
-    logWarn(QString("%1 %2 doesn't exist on map '%3'").arg(Event::eventGroupToString(event_group)).arg(event_id).arg(map_name));
+    logWarn(QString("%1 %2 doesn't exist on map '%3'").arg(Event::groupToString(event_group)).arg(event_id).arg(map_name));
 }
 
 void MainWindow::displayMapProperties() {
@@ -1639,7 +1639,7 @@ void MainWindow::copy() {
                 for (auto item : events) {
                     Event *event = item->event;
                     OrderedJson::object eventContainer;
-                    eventContainer["event_type"] = Event::eventTypeToString(event->getEventType());
+                    eventContainer["event_type"] = Event::typeToString(event->getEventType());
                     OrderedJson::object eventJson = event->buildEventJson(editor->project);
                     eventContainer["event"] = eventJson;
                     eventsArray.append(eventContainer);
@@ -1751,7 +1751,7 @@ void MainWindow::paste() {
                 for (QJsonValue event : events) {
                     // paste the event to the map
                     const QString typeString = event["event_type"].toString();
-                    Event::Type type = Event::eventTypeFromString(typeString);
+                    Event::Type type = Event::typeFromString(typeString);
 
                     if (this->editor->eventLimitReached(type)) {
                         logWarn(QString("Cannot paste event, the limit for type '%1' has been reached.").arg(typeString));
@@ -2009,7 +2009,7 @@ void MainWindow::addNewEvent(Event::Type type) {
 void MainWindow::tryAddEventTab(QWidget * tab) {
     auto group = getEventGroupFromTabWidget(tab);
     if (editor->map->getNumEvents(group))
-        ui->tabWidget_EventType->addTab(tab, QString("%1s").arg(Event::eventGroupToString(group)));
+        ui->tabWidget_EventType->addTab(tab, QString("%1s").arg(Event::groupToString(group)));
 }
 
 void MainWindow::displayEventTabs() {
diff --git a/src/project.cpp b/src/project.cpp
index 38b1810b..21dc5199 100644
--- a/src/project.cpp
+++ b/src/project.cpp
@@ -203,6 +203,21 @@ bool Project::readMapJson(const QString &mapName, QJsonDocument * out) {
     return true;
 }
 
+bool Project::loadMapEvent(Map *map, const QJsonObject &json, Event::Type defaultType) {
+    QString typeString = ParseUtil::jsonToQString(json["type"]);
+    Event::Type type = typeString.isEmpty() ? defaultType : Event::typeFromString(typeString);
+    Event* event = Event::create(type);
+    if (!event) {
+        return false;
+    }
+    if (!event->loadFromJson(json, this)) {
+        delete event;
+        return false;
+    }
+    map->addEvent(event);
+    return true;
+}
+
 bool Project::loadMapData(Map* map) {
     if (!map->isPersistedToFile()) {
         return true;
@@ -241,75 +256,22 @@ bool Project::loadMapData(Map* map) {
 
     // Events
     map->resetEvents();
-    QJsonArray objectEventsArr = mapObj["object_events"].toArray();
-    for (int i = 0; i < objectEventsArr.size(); i++) {
-        QJsonObject event = objectEventsArr[i].toObject();
-        // If clone objects are not enabled then no type field is present
-        QString type = projectConfig.eventCloneObjectEnabled ? ParseUtil::jsonToQString(event["type"]) : "object";
-        if (type.isEmpty() || type == "object") {
-            ObjectEvent *object = new ObjectEvent();
-            object->loadFromJson(event, this);
-            map->addEvent(object);
-        } else if (type == "clone") {
-            CloneObjectEvent *clone = new CloneObjectEvent();
-            if (clone->loadFromJson(event, this)) {
-                map->addEvent(clone);
+    static const QMap<QString, Event::Type> defaultEventTypes = {
+        // Map of the expected keys for each event group, and the default type of that group.
+        // If the default type is Type::None then each event must specify its type, or its an error.
+        {"object_events", Event::Type::Object},
+        {"warp_events",   Event::Type::Warp},
+        {"coord_events",  Event::Type::None},
+        {"bg_events",     Event::Type::None},
+    };
+    for (auto i = defaultEventTypes.constBegin(); i != defaultEventTypes.constEnd(); i++) {
+        QString eventGroupKey = i.key();
+        Event::Type defaultType = i.value();
+        const QJsonArray eventsJsonArr = mapObj[eventGroupKey].toArray();
+        for (int i = 0; i < eventsJsonArr.size(); i++) {
+            if (!loadMapEvent(map, eventsJsonArr.at(i).toObject(), defaultType)) {
+                logError(QString("Failed to load event for %1, in %2 at index %3.").arg(map->name()).arg(eventGroupKey).arg(i));
             }
-            else {
-                delete clone;
-            }
-        } else {
-            logError(QString("Map %1 object_event %2 has invalid type '%3'. Must be 'object' or 'clone'.").arg(map->name()).arg(i).arg(type));
-        }
-    }
-
-    QJsonArray warpEventsArr = mapObj["warp_events"].toArray();
-    for (int i = 0; i < warpEventsArr.size(); i++) {
-        QJsonObject event = warpEventsArr[i].toObject();
-        WarpEvent *warp = new WarpEvent();
-        if (warp->loadFromJson(event, this)) {
-            map->addEvent(warp);
-        }
-        else {
-            delete warp;
-        }
-    }
-
-    QJsonArray coordEventsArr = mapObj["coord_events"].toArray();
-    for (int i = 0; i < coordEventsArr.size(); i++) {
-        QJsonObject event = coordEventsArr[i].toObject();
-        QString type = ParseUtil::jsonToQString(event["type"]);
-        if (type == "trigger") {
-            TriggerEvent *coord = new TriggerEvent();
-            coord->loadFromJson(event, this);
-            map->addEvent(coord);
-        } else if (type == "weather") {
-            WeatherTriggerEvent *coord = new WeatherTriggerEvent();
-            coord->loadFromJson(event, this);
-            map->addEvent(coord);
-        } else {
-            logError(QString("Map %1 coord_event %2 has invalid type '%3'. Must be 'trigger' or 'weather'.").arg(map->name()).arg(i).arg(type));
-        }
-    }
-
-    QJsonArray bgEventsArr = mapObj["bg_events"].toArray();
-    for (int i = 0; i < bgEventsArr.size(); i++) {
-        QJsonObject event = bgEventsArr[i].toObject();
-        QString type = ParseUtil::jsonToQString(event["type"]);
-        if (type == "sign") {
-            SignEvent *bg = new SignEvent();
-            bg->loadFromJson(event, this);
-            map->addEvent(bg);
-        } else if (type == "hidden_item") {
-            HiddenItemEvent *bg = new HiddenItemEvent();
-            bg->loadFromJson(event, this);
-            map->addEvent(bg);
-        } else if (type == "secret_base") {
-            SecretBaseEvent *bg = new SecretBaseEvent();
-            bg->loadFromJson(event, this);
-            map->addEvent(bg);
-        } else {
-            logError(QString("Map %1 bg_event %2 has invalid type '%3'. Must be 'sign', 'hidden_item', or 'secret_base'.").arg(map->name()).arg(i).arg(type));
         }
     }