From 42575e5d5a4dcd76de76fd2d22eb367b7c457724 Mon Sep 17 00:00:00 2001
From: 0xFEEDC0DE64 <daniel@brunner.ninja>
Date: Fri, 29 Dec 2023 17:48:21 +0100
Subject: [PATCH] Add collision events and fix a few bugs when objects are
 renamed/deleted

---
 src/editor/dialogs/addeventdialog.cpp         |  29 +-
 src/editor/dialogs/addeventdialog.h           |  11 +-
 src/editor/dialogs/addeventdialog.ui          |   6 +-
 src/editor/dialogs/objectpropertiesdialog.cpp |  32 +-
 src/editor/dialogs/objectpropertiesdialog.h   |   1 +
 src/editor/dialogs/roompropertiesdialog.cpp   |  36 +-
 src/editor/dialogs/roompropertiesdialog.h     |   2 +-
 src/editor/icons/event-collision.png          | Bin 0 -> 8081 bytes
 src/editor/models/objecteventsmodel.cpp       | 329 +++++++++++++++---
 src/editor/models/objecteventsmodel.h         |  21 +-
 src/editor/models/projecttreemodel.cpp        |  36 +-
 src/editor/resources_editor.qrc               |   1 +
 src/projectcontainer.cpp                      |   6 +-
 src/projectcontainer.h                        |   3 +
 14 files changed, 416 insertions(+), 97 deletions(-)
 create mode 100644 src/editor/icons/event-collision.png

diff --git a/src/editor/dialogs/addeventdialog.cpp b/src/editor/dialogs/addeventdialog.cpp
index e99610b..e994f9f 100644
--- a/src/editor/dialogs/addeventdialog.cpp
+++ b/src/editor/dialogs/addeventdialog.cpp
@@ -2,9 +2,13 @@
 #include "ui_addeventdialog.h"
 
 #include <QMessageBox>
+#include <QMenu>
 
-AddEventDialog::AddEventDialog(QWidget *parent) :
+#include "models/projecttreemodel.h"
+
+AddEventDialog::AddEventDialog(ProjectTreeModel &projectModel, QWidget *parent) :
     QDialog{parent},
+    m_projectModel{projectModel},
     m_ui{std::make_unique<Ui::AddEventDialog>()}
 {
     m_ui->setupUi(this);
@@ -27,6 +31,29 @@ AddEventDialog::AddEventDialog(QWidget *parent) :
             this, [this](){ m_eventType = Object::EventType::Draw; accept(); });
     connect(m_ui->pushButtonStep, &QAbstractButton::clicked,
             this, [this](){ m_eventType = Object::EventType::Step; accept(); });
+
+    auto menu = new QMenu;
+    connect(menu, &QMenu::aboutToShow, menu, [this,menu](){
+        for (const Object &object : m_projectModel.project()->objects)
+        {
+            QIcon icon;
+            if (!object.spriteName.isEmpty())
+            {
+                const auto &sprites = m_projectModel.project()->sprites;
+                const auto iter = std::find_if(std::cbegin(sprites), std::cend(sprites),
+                                               [&](const Sprite &sprite){ return sprite.name == object.spriteName; });
+                if (iter != std::cend(sprites))
+                {
+                    if (!iter->pixmaps.empty())
+                        icon = iter->pixmaps.front();
+                }
+            }
+            menu->addAction(icon, object.name, this, [this,&object](){
+                m_eventType = object.name; accept();
+            });
+        }
+    }, Qt::SingleShotConnection);
+    m_ui->pushButtonCollision->setMenu(menu);
 }
 
 AddEventDialog::~AddEventDialog() = default;
diff --git a/src/editor/dialogs/addeventdialog.h b/src/editor/dialogs/addeventdialog.h
index 3b88fd6..ce4c23b 100644
--- a/src/editor/dialogs/addeventdialog.h
+++ b/src/editor/dialogs/addeventdialog.h
@@ -3,26 +3,31 @@
 #include <QDialog>
 
 #include <optional>
+#include <variant>
 
 #include "projectcontainer.h"
 
 namespace Ui { class AddEventDialog; }
 
+class ProjectTreeModel;
+
 class AddEventDialog : public QDialog
 {
     Q_OBJECT
 
 public:
-    explicit AddEventDialog(QWidget *parent = nullptr);
+    explicit AddEventDialog(ProjectTreeModel &projectModel, QWidget *parent = nullptr);
     ~AddEventDialog();
 
-    Object::EventType eventType() const { return *m_eventType; }
+    const std::optional<std::variant<Object::EventType, QString>> &eventType() const { return m_eventType; }
 
     void accept() override;
     void reject() override;
 
 private:
+    ProjectTreeModel &m_projectModel;
+
     const std::unique_ptr<Ui::AddEventDialog> m_ui;
 
-    std::optional<Object::EventType> m_eventType;
+    std::optional<std::variant<Object::EventType, QString>> m_eventType;
 };
diff --git a/src/editor/dialogs/addeventdialog.ui b/src/editor/dialogs/addeventdialog.ui
index bfd4e6b..3d4e022 100644
--- a/src/editor/dialogs/addeventdialog.ui
+++ b/src/editor/dialogs/addeventdialog.ui
@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>265</width>
-    <height>221</height>
+    <height>238</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -82,6 +82,10 @@
        <property name="text">
         <string>C&amp;ollision</string>
        </property>
+       <property name="icon">
+        <iconset resource="../resources_editor.qrc">
+         <normaloff>:/qtgameengine/icons/event-collision.png</normaloff>:/qtgameengine/icons/event-collision.png</iconset>
+       </property>
       </widget>
      </item>
      <item row="1" column="0">
diff --git a/src/editor/dialogs/objectpropertiesdialog.cpp b/src/editor/dialogs/objectpropertiesdialog.cpp
index ed1fae6..def3293 100644
--- a/src/editor/dialogs/objectpropertiesdialog.cpp
+++ b/src/editor/dialogs/objectpropertiesdialog.cpp
@@ -19,7 +19,8 @@ ObjectPropertiesDialog::ObjectPropertiesDialog(Object &object, ProjectTreeModel
     m_projectModel{projectModel},
     m_mainWindow{mainWindow},
     m_events{m_object.events},
-    m_eventsModel{std::make_unique<ObjectEventsModel>(m_events)},
+    m_collisionEvents{m_object.collisionEvents},
+    m_eventsModel{std::make_unique<ObjectEventsModel>(m_events, m_collisionEvents)},
     m_menuSprites{new QMenu{this}},
     m_spriteName{object.spriteName}
 {
@@ -132,6 +133,7 @@ void ObjectPropertiesDialog::accept()
     m_object.depth = m_ui->spinBoxDepth->value();
     m_object.persistent = m_ui->checkBoxPersistent->isChecked();
     m_object.events = std::move(m_events);
+    m_object.collisionEvents = std::move(m_collisionEvents);
 
     QDialog::accept();
 }
@@ -204,12 +206,11 @@ void ObjectPropertiesDialog::showInformation()
 
 void ObjectPropertiesDialog::addEvent()
 {
-    AddEventDialog dialog{this};
+    AddEventDialog dialog{m_projectModel, this};
     if (dialog.exec() == QDialog::Accepted)
-    {
-        if (!m_eventsModel->addEvent(dialog.eventType()))
-            QMessageBox::warning(this, tr("Could not add Event!"), tr("Could not add Event!"));
-    }
+        if (const auto &eventType = dialog.eventType())
+            if (!m_eventsModel->addEvent(*eventType))
+                QMessageBox::warning(this, tr("Could not add Event!"), tr("Could not add Event!"));
 }
 
 void ObjectPropertiesDialog::deleteEvent()
@@ -235,12 +236,13 @@ void ObjectPropertiesDialog::replaceEvent()
     if (!event)
         return;
 
-    AddEventDialog dialog{this};
+    std::variant<Object::EventType, QString> x = event->first;
+
+    AddEventDialog dialog{m_projectModel, this};
     if (dialog.exec() == QDialog::Accepted)
-    {
-        if (!m_eventsModel->changeEvent(event->first, dialog.eventType()))
+        if (const auto &eventType = dialog.eventType())
+        if (!m_eventsModel->changeEvent(event->first, *eventType))
             QMessageBox::warning(this, tr("Could not change Event!"), tr("Could not change Event!"));
-    }
 }
 
 void ObjectPropertiesDialog::duplicateEvent()
@@ -329,7 +331,7 @@ void ObjectPropertiesDialog::currentEventChanged(const QModelIndex &index)
     if (index.isValid())
     {
         if (auto event = m_eventsModel->getEvent(index))
-            m_ui->actionsWidget->setActionsContainer(&event->second);
+            m_ui->actionsWidget->setActionsContainer(&event->second.get());
         else
             goto none;
     }
@@ -343,13 +345,13 @@ none:
 void ObjectPropertiesDialog::eventsContextMenuRequested(const QPoint &pos)
 {
     const auto index = m_ui->listViewEvents->indexAt(pos);
-    auto event = index.isValid() ? m_eventsModel->getEvent(index) : nullptr;
+    auto event = index.isValid() ? m_eventsModel->getEvent(index) : std::nullopt;
 
     QMenu menu{this};
     menu.addAction(tr("&Add Event"), this, &ObjectPropertiesDialog::addEvent);
-    menu.addAction(tr("&Change Event"), this, &ObjectPropertiesDialog::replaceEvent)->setEnabled(event);
-    menu.addAction(tr("&Duplicate Event"), this, &ObjectPropertiesDialog::duplicateEvent)->setEnabled(event);
-    menu.addAction(tr("D&elete Event"), this, &ObjectPropertiesDialog::deleteEvent)->setEnabled(event);
+    menu.addAction(tr("&Change Event"), this, &ObjectPropertiesDialog::replaceEvent)->setEnabled(event.has_value());
+    menu.addAction(tr("&Duplicate Event"), this, &ObjectPropertiesDialog::duplicateEvent)->setEnabled(event.has_value());
+    menu.addAction(tr("D&elete Event"), this, &ObjectPropertiesDialog::deleteEvent)->setEnabled(event.has_value());
     menu.exec(m_ui->listViewEvents->viewport()->mapToGlobal(pos));
 }
 
diff --git a/src/editor/dialogs/objectpropertiesdialog.h b/src/editor/dialogs/objectpropertiesdialog.h
index 8f6fc61..c470629 100644
--- a/src/editor/dialogs/objectpropertiesdialog.h
+++ b/src/editor/dialogs/objectpropertiesdialog.h
@@ -60,6 +60,7 @@ private:
     MainWindow * const m_mainWindow;
 
     Object::events_container_t m_events;
+    Object::collision_events_container_t m_collisionEvents;
 
     const std::unique_ptr<ObjectEventsModel> m_eventsModel;
 
diff --git a/src/editor/dialogs/roompropertiesdialog.cpp b/src/editor/dialogs/roompropertiesdialog.cpp
index 1bc89bd..41e78d1 100644
--- a/src/editor/dialogs/roompropertiesdialog.cpp
+++ b/src/editor/dialogs/roompropertiesdialog.cpp
@@ -343,29 +343,35 @@ void RoomPropertiesDialog::spritePixmapsChanged(const Sprite &sprite)
     m_ui->labelObjectPreview->setPixmap(std::move(pixmap));
 }
 
-void RoomPropertiesDialog::objectNameChanged(const Object &object)
+void RoomPropertiesDialog::objectNameChanged(const Object &object, const QString &oldName)
 {
-    if (!m_selectedObject)
-        return;
+    if (m_selectedObject && &object == m_selectedObject)
+        m_ui->lineEditObject->setText(object.name);
 
-    if (&object != m_selectedObject)
-        return;
+    for (auto &obj : m_objects)
+    {
+        if (obj.objectName != oldName)
+            continue;
 
-    m_ui->lineEditObject->setText(object.name);
+        obj.objectName = object.name;
+    }
 }
 
 void RoomPropertiesDialog::objectAboutToBeRemoved(const Object &object)
 {
-    if (!m_selectedObject)
-        return;
+    if (m_selectedObject && &object == m_selectedObject)
+    {
+        m_selectedObject = nullptr;
+        m_ui->lineEditObject->clear();
+        m_ui->labelObjectPreview->setPixmap({});
+        m_ui->roomEditWidget->setSelectedObject(nullptr);
+    }
 
-    if (&object != m_selectedObject)
-        return;
-
-    m_selectedObject = nullptr;
-    m_ui->lineEditObject->clear();
-    m_ui->labelObjectPreview->setPixmap({});
-    m_ui->roomEditWidget->setSelectedObject(nullptr);
+    for (auto iter = std::begin(m_objects); iter != std::end(m_objects);)
+        if (iter->objectName == object.name)
+            iter = m_objects.erase(iter);
+        else
+            iter++;
 }
 
 void RoomPropertiesDialog::objectSpriteNameChanged(const Object &object)
diff --git a/src/editor/dialogs/roompropertiesdialog.h b/src/editor/dialogs/roompropertiesdialog.h
index ddb02b1..1d551e8 100644
--- a/src/editor/dialogs/roompropertiesdialog.h
+++ b/src/editor/dialogs/roompropertiesdialog.h
@@ -41,7 +41,7 @@ private slots:
 
     void roomNameChanged(const Room &room);
     void spritePixmapsChanged(const Sprite &sprite);
-    void objectNameChanged(const Object &object);
+    void objectNameChanged(const Object &object, const QString &oldName);
     void objectAboutToBeRemoved(const Object &object);
     void objectSpriteNameChanged(const Object &object);
 
diff --git a/src/editor/icons/event-collision.png b/src/editor/icons/event-collision.png
new file mode 100644
index 0000000000000000000000000000000000000000..c8a0c483f9603345bc7362192d5138daf29f9795
GIT binary patch
literal 8081
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

literal 0
HcmV?d00001

diff --git a/src/editor/models/objecteventsmodel.cpp b/src/editor/models/objecteventsmodel.cpp
index 3e26084..afc1acf 100644
--- a/src/editor/models/objecteventsmodel.cpp
+++ b/src/editor/models/objecteventsmodel.cpp
@@ -5,56 +5,78 @@
 
 #include "futurecpp.h"
 
-ObjectEventsModel::ObjectEventsModel(Object::events_container_t &events, QObject *parent) :
+ObjectEventsModel::ObjectEventsModel(Object::events_container_t &events, Object::collision_events_container_t &collisionEvents,
+                                     QObject *parent) :
     QAbstractListModel{parent},
-    m_events{events}
+    m_events{events},
+    m_collisionEvents{collisionEvents}
 {
 }
 
 int ObjectEventsModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
-    return m_events.size();
+    return m_events.size() + m_collisionEvents.size();
 }
 
 QVariant ObjectEventsModel::data(const QModelIndex &index, int role) const
 {
     Q_UNUSED(index)
 
-    if (index.row() < 0 || std::size_t(index.row()) >= m_events.size())
+    if (index.row() < 0)
     {
         qWarning() << "row out of bounds" << index.row();
         return {};
     }
-
-    const auto &pair = *std::next(std::cbegin(m_events), index.row());
-
-    switch (role)
+    else if (std::size_t(index.row()) < m_events.size())
     {
-    case Qt::DisplayRole:
-    case Qt::EditRole:
-        switch (pair.first)
+        const auto &pair = *std::next(std::cbegin(m_events), index.row());
+
+        switch (role)
         {
-        case Object::EventType::Create:  return tr("Create");
-        case Object::EventType::Destroy: return tr("Destroy");
-        case Object::EventType::Step:    return tr("Step");
-        case Object::EventType::Draw:    return tr("Draw");
-        default:
-            qWarning() << "unknown event type" << std::to_underlying(pair.first);
-            return QString::number(std::to_underlying(pair.first));
+        case Qt::DisplayRole:
+        case Qt::EditRole:
+            switch (pair.first)
+            {
+            case Object::EventType::Create:  return tr("Create");
+            case Object::EventType::Destroy: return tr("Destroy");
+            case Object::EventType::Step:    return tr("Step");
+            case Object::EventType::Draw:    return tr("Draw");
+            default:
+                qWarning() << "unknown event type" << std::to_underlying(pair.first);
+                return QString::number(std::to_underlying(pair.first));
+            }
+        case Qt::DecorationRole:
+            switch (pair.first)
+            {
+            case Object::EventType::Create:  return QIcon{":/qtgameengine/icons/event-create.png"};
+            case Object::EventType::Destroy: return QIcon{":/qtgameengine/icons/event-destroy.png"};
+            case Object::EventType::Step:    return QIcon{":/qtgameengine/icons/event-step.png"};
+            case Object::EventType::Draw:    return QIcon{":/qtgameengine/icons/event-draw.png"};
+            default:
+                qWarning() << "unknown event type" << std::to_underlying(pair.first);
+                return {};
+            }
         }
-    case Qt::DecorationRole:
-        switch (pair.first)
+    }
+    else if (std::size_t(index.row()) < m_collisionEvents.size() + m_events.size())
+    {
+        const auto &pair = *std::next(std::cbegin(m_collisionEvents), index.row() - m_events.size());
+
+        switch (role)
         {
-        case Object::EventType::Create:  return QIcon{":/qtgameengine/icons/event-create.png"};
-        case Object::EventType::Destroy: return QIcon{":/qtgameengine/icons/event-destroy.png"};
-        case Object::EventType::Step:    return QIcon{":/qtgameengine/icons/event-step.png"};
-        case Object::EventType::Draw:    return QIcon{":/qtgameengine/icons/event-draw.png"};
-        default:
-            qWarning() << "unknown event type" << std::to_underlying(pair.first);
-            return {};
+        case Qt::DisplayRole:
+        case Qt::EditRole:
+            return pair.first;
+        case Qt::DecorationRole:
+            return QIcon{":/qtgameengine/icons/event-collision.png"};
         }
     }
+    else
+    {
+        qWarning() << "row out of bounds" << index.row();
+        return {};
+    }
 
     return {};
 }
@@ -63,27 +85,62 @@ bool ObjectEventsModel::removeRows(int row, int count, const QModelIndex &parent
 {
     Q_UNUSED(parent)
 
-    if (row < 0 || std::size_t(row) >= m_events.size())
+    if (row < 0 || std::size_t(row) >= m_events.size() + m_collisionEvents.size())
     {
         qWarning() << "unexpected row" << row;
         return false;
     }
 
-    if (count < 0 || std::size_t(count) > m_events.size() - row)
+    if (count < 0 || std::size_t(count) > m_events.size() + m_collisionEvents.size() - row)
     {
         qWarning() << "unexpected row+count" << count << row;
         return false;
     }
 
     beginRemoveRows({}, row, row + count - 1);
-    auto begin = std::next(std::begin(m_events), row);
-    auto end = std::next(begin, count);
-    m_events.erase(begin, end);
+
+    if (std::size_t(row) < m_events.size())
+    {
+        const auto remaining = m_events.size() - row;
+        const auto begin = std::next(std::begin(m_events), row);
+        const auto end = std::next(begin, std::min<std::size_t>(count, remaining));
+        m_events.erase(begin, end);
+
+        if (std::size_t(count) > remaining)
+        {
+            count -= remaining;
+
+            const auto begin = std::begin(m_collisionEvents);
+            const auto end = std::next(begin, count);
+            m_collisionEvents.erase(begin, end);
+        }
+    }
+    else if (std::size_t(row) < m_events.size() + m_collisionEvents.size())
+    {
+        qDebug() << row - m_events.size();
+        qDebug() << count;
+        qDebug() << m_collisionEvents.size();
+
+        const auto begin = std::next(std::begin(m_collisionEvents), row - m_events.size());
+        const auto end = std::next(begin, count);
+        m_collisionEvents.erase(begin, end);
+    }
+
     endRemoveRows();
 
     return true;
 }
 
+bool ObjectEventsModel::addEvent(std::variant<Object::EventType, QString> eventType)
+{
+    if (const auto &type = std::get_if<Object::EventType>(&eventType))
+        return addEvent(*type);
+    if (const auto &object = std::get_if<QString>(&eventType))
+        return addEvent(*object);
+    qCritical() << "not implemented";
+    return false;
+}
+
 bool ObjectEventsModel::addEvent(Object::EventType eventType)
 {
     if (m_events.contains(eventType))
@@ -122,6 +179,72 @@ bool ObjectEventsModel::addEvent(Object::EventType eventType)
     return true;
 }
 
+bool ObjectEventsModel::addEvent(const QString &object)
+{
+    if (m_collisionEvents.contains(object))
+    {
+        qWarning() << object << "duplicate";
+        return false;
+    }
+
+    // temporary copy to find row before inserting, as its needed for beginInsertRows()
+    auto tempevents = m_collisionEvents;
+
+    const auto &tempInsertResult = tempevents.insert(std::make_pair(object, ActionsContainer{}));
+    if (!tempInsertResult.second)
+    {
+        qWarning() << "temp inserting failed!";
+        return false;
+    }
+
+    const auto tempNewRow = std::distance(std::begin(tempevents), tempInsertResult.first);
+
+
+    beginInsertRows({}, tempNewRow + m_events.size(), tempNewRow + m_events.size());
+
+    const auto &insertResult = m_collisionEvents.insert(std::make_pair(object, ActionsContainer{}));
+    if (!insertResult.second)
+    {
+        qWarning() << "inserting failed!";
+        return false;
+    }
+
+    const auto newRow = std::distance(std::begin(m_collisionEvents), insertResult.first);
+    Q_ASSERT(tempNewRow == newRow);
+
+    endInsertRows();
+
+    return true;
+}
+
+bool ObjectEventsModel::changeEvent(std::variant<Object::EventType, QString> eventType, std::variant<Object::EventType, QString> newEventType)
+{
+    if (const auto &type = std::get_if<Object::EventType>(&eventType))
+    {
+        if (const auto &newType = std::get_if<Object::EventType>(&newEventType))
+            return changeEvent(*type, *newType);
+        if (const auto &newObject = std::get_if<QString>(&newEventType))
+        {
+            //return changeEvent(*type, *newObject);
+        }
+        qCritical() << "not implemented";
+        return false;
+    }
+    if (const auto &object = std::get_if<QString>(&eventType))
+    {
+        if (const auto &newType = std::get_if<Object::EventType>(&newEventType))
+        {
+            //return changeEvent(*object, *newType);
+        }
+        if (const auto &newObject = std::get_if<QString>(&newEventType))
+            return changeEvent(*object, *newObject);
+        qCritical() << "not implemented";
+        return false;
+    }
+    qCritical() << "not implemented";
+    return false;
+}
+
 bool ObjectEventsModel::changeEvent(Object::EventType eventType, Object::EventType newEventType)
 {
     const auto iter = m_events.find(eventType);
@@ -137,6 +260,12 @@ bool ObjectEventsModel::changeEvent(Object::EventType eventType, Object::EventTy
         return true;
     }
 
+    if (m_events.contains(newEventType))
+    {
+        qWarning() << std::to_underlying(eventType) << "duplicate";
+        return false;
+    }
+
     auto container = std::move(iter->second);
 
     const auto oldRow = std::distance(std::begin(m_events), iter);
@@ -175,6 +304,75 @@ bool ObjectEventsModel::changeEvent(Object::EventType eventType, Object::EventTy
     return true;
 }
 
+bool ObjectEventsModel::changeEvent(const QString &object, const QString &newObject)
+{
+    const auto iter = m_collisionEvents.find(object);
+    if (iter == std::cend(m_collisionEvents))
+    {
+        qWarning() << object << "not found";
+        return false;
+    }
+
+    if (object == newObject)
+    {
+        qWarning() << "same event again";
+        return true;
+    }
+
+    if (m_collisionEvents.contains(newObject))
+    {
+        qWarning() << newObject << "duplicate";
+        return false;
+    }
+
+    auto container = std::move(iter->second);
+
+    const auto oldRow = std::distance(std::begin(m_collisionEvents), iter);
+
+    beginRemoveRows({}, oldRow + m_events.size(), oldRow + m_events.size());
+    m_collisionEvents.erase(iter);
+    endRemoveRows();
+
+    // temporary copy to find row before inserting, as its needed for beginInsertRows()
+    auto tempevents = m_collisionEvents;
+
+    const auto &tempInsertResult = tempevents.insert(std::make_pair(newObject, ActionsContainer{}));
+    if (!tempInsertResult.second)
+    {
+        qWarning() << "temp inserting failed!";
+        return false;
+    }
+
+    const auto tempNewRow = std::distance(std::begin(tempevents), tempInsertResult.first);
+
+
+    beginInsertRows({}, tempNewRow + m_events.size(), tempNewRow + m_events.size());
+
+    const auto &insertResult = m_collisionEvents.insert(std::make_pair(newObject, std::move(container)));
+    if (!insertResult.second)
+    {
+        qWarning() << "inserting failed!";
+        return false;
+    }
+
+    const auto newRow = std::distance(std::begin(m_collisionEvents), insertResult.first);
+    Q_ASSERT(tempNewRow == newRow);
+
+    endInsertRows();
+
+    return true;
+}
+
+bool ObjectEventsModel::removeEvent(std::variant<Object::EventType, QString> eventType)
+{
+    if (const auto &type = std::get_if<Object::EventType>(&eventType))
+        return removeEvent(*type);
+    if (const auto &object = std::get_if<QString>(&eventType))
+        return removeEvent(*object);
+    qCritical() << "not implemented";
+    return false;
+}
+
 bool ObjectEventsModel::removeEvent(Object::EventType eventType)
 {
     const auto iter = m_events.find(eventType);
@@ -193,46 +391,79 @@ bool ObjectEventsModel::removeEvent(Object::EventType eventType)
     return true;
 }
 
-std::pair<const Object::EventType, ActionsContainer> *ObjectEventsModel::getEvent(const QModelIndex &index)
+bool ObjectEventsModel::removeEvent(const QString &object)
+{
+    Q_UNUSED(object);
+    qCritical() << "not implemented";
+    return false;
+}
+
+auto ObjectEventsModel::getEvent(const QModelIndex &index) -> get_event_result_t
 {
     if (!index.isValid())
     {
         qWarning() << "unexpected invalid index";
-        return nullptr;
+        return std::nullopt;
     }
 
     return getEvent(index.row());
 }
 
-const std::pair<const Object::EventType, ActionsContainer> *ObjectEventsModel::getEvent(const QModelIndex &index) const
+auto ObjectEventsModel::getEvent(const QModelIndex &index) const -> const_get_event_result_t
 {
     if (!index.isValid())
     {
         qWarning() << "unexpected invalid index";
-        return nullptr;
+        return std::nullopt;
     }
 
     return getEvent(index.row());
 }
 
-std::pair<const Object::EventType, ActionsContainer> *ObjectEventsModel::getEvent(int row)
+auto ObjectEventsModel::getEvent(int row) -> get_event_result_t
 {
-    if (row < 0 || std::size_t(row) >= m_events.size())
+    if (row < 0)
     {
         qWarning() << "unexpected row" << row;
-        return nullptr;
+        return std::nullopt;
     }
-
-    return &*std::next(std::begin(m_events), row);
-}
-
-const std::pair<const Object::EventType, ActionsContainer> *ObjectEventsModel::getEvent(int row) const
-{
-    if (row < 0 || std::size_t(row) >= m_events.size())
+    else if (std::size_t(row) < m_events.size())
+    {
+        auto iter = std::next(std::begin(m_events), row);
+        return std::make_pair(iter->first, std::ref(iter->second));
+    }
+    else if (std::size_t(row) < m_events.size() + m_collisionEvents.size())
+    {
+        auto iter = std::next(std::begin(m_collisionEvents), row - m_events.size());
+        return std::make_pair(iter->first, std::ref(iter->second));
+    }
+    else
     {
         qWarning() << "unexpected row" << row;
-        return nullptr;
+        return std::nullopt;
+    }
+}
+
+auto ObjectEventsModel::getEvent(int row) const -> const_get_event_result_t
+{
+    if (row < 0)
+    {
+        qWarning() << "unexpected row" << row;
+        return std::nullopt;
+    }
+    else if (std::size_t(row) >= m_events.size())
+    {
+        auto iter = std::next(std::cbegin(m_events), row);
+        return std::make_pair(iter->first, std::cref(iter->second));
+    }
+    else if (std::size_t(row) >= m_events.size() + m_collisionEvents.size())
+    {
+        auto iter = std::next(std::cbegin(m_collisionEvents), row - m_events.size());
+        return std::make_pair(iter->first, std::cref(iter->second));
+    }
+    else
+    {
+        qWarning() << "unexpected row" << row;
+        return std::nullopt;
     }
-
-    return &*std::next(std::cbegin(m_events), row);
 }
diff --git a/src/editor/models/objecteventsmodel.h b/src/editor/models/objecteventsmodel.h
index 0e542a9..5dba891 100644
--- a/src/editor/models/objecteventsmodel.h
+++ b/src/editor/models/objecteventsmodel.h
@@ -11,21 +11,32 @@ class ObjectEventsModel : public QAbstractListModel
     Q_OBJECT
 
 public:
-    explicit ObjectEventsModel(Object::events_container_t &events, QObject *parent = nullptr);
+    explicit ObjectEventsModel(Object::events_container_t &events, Object::collision_events_container_t &collisionEvents,
+                               QObject *parent = nullptr);
 
     int rowCount(const QModelIndex &parent) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex{}) override;
 
+    bool addEvent(std::variant<Object::EventType, QString> eventType);
     bool addEvent(Object::EventType eventType);
+    bool addEvent(const QString &object);
+    bool changeEvent(std::variant<Object::EventType, QString> eventType, std::variant<Object::EventType, QString> newEventType);
     bool changeEvent(Object::EventType eventType, Object::EventType newEventType);
+    bool changeEvent(const QString &object, const QString &newObject);
+    bool removeEvent(std::variant<Object::EventType, QString> eventType);
     bool removeEvent(Object::EventType eventType);
+    bool removeEvent(const QString &object);
 
-    std::pair<const Object::EventType, ActionsContainer> *getEvent(const QModelIndex &index);
-    const std::pair<const Object::EventType, ActionsContainer> *getEvent(const QModelIndex &index) const;
-    std::pair<const Object::EventType, ActionsContainer> *getEvent(int row);
-    const std::pair<const Object::EventType, ActionsContainer> *getEvent(int row) const;
+    using get_event_result_t = std::optional<std::pair<std::variant<Object::EventType, QString>, std::reference_wrapper<ActionsContainer>>>;
+    using const_get_event_result_t = std::optional<std::pair<std::variant<Object::EventType, QString>, std::reference_wrapper<const ActionsContainer>>>;
+
+    get_event_result_t getEvent(const QModelIndex &index);
+    const_get_event_result_t getEvent(const QModelIndex &index) const;
+    get_event_result_t getEvent(int row);
+    const_get_event_result_t getEvent(int row) const;
 
 private:
     Object::events_container_t &m_events;
+    Object::collision_events_container_t &m_collisionEvents;
 };
diff --git a/src/editor/models/projecttreemodel.cpp b/src/editor/models/projecttreemodel.cpp
index d4cf477..839ad9e 100644
--- a/src/editor/models/projecttreemodel.cpp
+++ b/src/editor/models/projecttreemodel.cpp
@@ -959,6 +959,16 @@ template<> void ProjectTreeModel::onBeforeRemove<Sprite>(const Sprite &sprite)
     }
 }
 
+template<> void ProjectTreeModel::onBeforeRemove<Object>(const Object &object)
+{
+    for (auto &room : m_project->rooms)
+        for (auto iter = std::begin(room.objects); iter != std::end(room.objects); )
+            if (iter->objectName == object.name)
+                iter = room.objects.erase(iter);
+            else
+                iter++;
+}
+
 template<typename T> void ProjectTreeModel::onBeforeRename(const T &entry, const QString &newName)
 {
     Q_UNUSED(entry)
@@ -973,22 +983,38 @@ template<typename T> void ProjectTreeModel::onAfterRename(const T &entry, const
 
 template<> void ProjectTreeModel::onAfterRename<Sprite>(const Sprite &sprite, const QString &oldName)
 {
-    for (auto iter = std::begin(m_project->objects); iter != std::end(m_project->objects); iter++)
+    for (auto &object : m_project->objects)
     {
-        if (iter->spriteName != oldName)
+        if (object.spriteName != oldName)
             continue;
 
-        auto oldSpriteName = std::move(iter->spriteName);
+        auto oldSpriteName = std::move(object.spriteName);
 
-        iter->spriteName = sprite.name;
+        object.spriteName = sprite.name;
 
 //        const auto index = this->index(std::distance(std::begin(m_project->objects), iter), 0, rootFor<Object>());
 //        emit dataChanged(index, index, {Qt::DecorationRole});
 
-        emit objectSpriteNameChanged(*iter, std::move(oldSpriteName));
+        emit objectSpriteNameChanged(object, std::move(oldSpriteName));
     }
 }
 
+template<> void ProjectTreeModel::onAfterRename<Object>(const Object &object, const QString &oldName)
+{
+    for (auto &room : m_project->rooms)
+    {
+        for (auto &obj : room.objects)
+        {
+            if (obj.objectName != oldName)
+                continue;
+
+            obj.objectName = object.name;
+        }
+    }
+
+    // TODO object collision events
+}
+
 template<typename T>
 QString ProjectTreeModel::getFreeNameFor(const std::list<T> &container)
 {
diff --git a/src/editor/resources_editor.qrc b/src/editor/resources_editor.qrc
index 8a7be93..c2f0725 100644
--- a/src/editor/resources_editor.qrc
+++ b/src/editor/resources_editor.qrc
@@ -76,6 +76,7 @@
         <file>icons/info.png</file>
         <file>icons/merge.png</file>
         <file>icons/sort.png</file>
+        <file>icons/event-collision.png</file>
         <file>icons/event-create.png</file>
         <file>icons/event-destroy.png</file>
         <file>icons/event-step.png</file>
diff --git a/src/projectcontainer.cpp b/src/projectcontainer.cpp
index d2f14a5..56346d2 100644
--- a/src/projectcontainer.cpp
+++ b/src/projectcontainer.cpp
@@ -306,7 +306,8 @@ QDataStream &operator<<(QDataStream &ds, const Object &object)
        << object.solid
        << object.depth
        << object.persistent
-       << object.events;
+       << object.events
+       << object.collisionEvents;
     return ds;
 }
 
@@ -318,7 +319,8 @@ QDataStream &operator>>(QDataStream &ds, Object &object)
        >> object.solid
        >> object.depth
        >> object.persistent
-       >> object.events;
+       >> object.events
+       >> object.collisionEvents;
     return ds;
 }
 
diff --git a/src/projectcontainer.h b/src/projectcontainer.h
index 15052c7..8d16478 100644
--- a/src/projectcontainer.h
+++ b/src/projectcontainer.h
@@ -2,6 +2,7 @@
 
 #include <vector>
 #include <list>
+#include <map>
 
 #include <QString>
 #include <QPixmap>
@@ -117,6 +118,7 @@ struct Object
     };
 
     using events_container_t = std::map<EventType, ActionsContainer>;
+    using collision_events_container_t = std::map<QString, ActionsContainer>;
 
     QString name;
     QString spriteName;
@@ -125,6 +127,7 @@ struct Object
     int depth{};
     bool persistent{};
     events_container_t events;
+    collision_events_container_t collisionEvents;
 };
 
 struct Room