Update filepaths and var names from 'map_object' -> 'event_object'

editor.cpp

     if (collision_item) {
         collision_item->setVisible(false);
     }
-    if (objects_group) {
-        objects_group->setVisible(false);
+    if (events_group) {
+        events_group->setVisible(false);
     }
     setBorderItemsVisible(true);
     setConnectionItemsVisible(false);
     if (map_item) {
         map_item->setVisible(false);
     }
-    if (objects_group) {
-        objects_group->setVisible(false);
+    if (events_group) {
+        events_group->setVisible(false);
     }
     setBorderItemsVisible(true);
     setConnectionItemsVisible(false);
 
 void Editor::setEditingObjects() {
     current_view = map_item;
-    if (objects_group) {
-        objects_group->setVisible(true);
+    if (events_group) {
+        events_group->setVisible(true);
     }
     if (map_item) {
         map_item->setVisible(true);
     if (collision_item) {
         collision_item->setVisible(false);
     }
-    if (objects_group) {
-        objects_group->setVisible(false);
+    if (events_group) {
+        events_group->setVisible(false);
     }
     setBorderItemsVisible(true, 0.4);
     setConnectionItemsVisible(true);
         map = project->loadMap(map_name);
         displayMap();
         selected_events->clear();
-        updateSelectedObjects();
+        updateSelectedEvents();
     }
 }
 
     collision_item->draw();
     scene->addItem(collision_item);
 
-    objects_group = new EventGroup;
-    scene->addItem(objects_group);
+    events_group = new EventGroup;
+    scene->addItem(events_group);
 
     if (map_item) {
         map_item->setVisible(false);
     if (collision_item) {
         collision_item->setVisible(false);
     }
-    if (objects_group) {
-        objects_group->setVisible(false);
+    if (events_group) {
+        events_group->setVisible(false);
     }
 
     int tw = 16;
     displayMetatiles();
     displayCollisionMetatiles();
     displayElevationMetatiles();
-    displayMapObjects();
+    displayMapEvents();
     displayMapConnections();
     displayMapBorder();
     displayMapGrid();
     scene_elevation_metatiles->addItem(elevation_metatiles_item);
 }
 
-void Editor::displayMapObjects() {
-    for (QGraphicsItem *child : objects_group->childItems()) {
-        objects_group->removeFromGroup(child);
+void Editor::displayMapEvents() {
+    for (QGraphicsItem *child : events_group->childItems()) {
+        events_group->removeFromGroup(child);
     }
 
     QList<Event *> events = map->getAllEvents();
-    project->loadObjectPixmaps(events);
+    project->loadEventPixmaps(events);
     for (Event *event : events) {
-        addMapObject(event);
+        addMapEvent(event);
     }
     //objects_group->setFiltersChildEvents(false);
-    objects_group->setHandlesChildEvents(false);
+    events_group->setHandlesChildEvents(false);
 
     emit objectsChanged();
 }
 
-DraggablePixmapItem *Editor::addMapObject(Event *event) {
+DraggablePixmapItem *Editor::addMapEvent(Event *event) {
     DraggablePixmapItem *object = new DraggablePixmapItem(event);
     object->editor = this;
-    objects_group->addToGroup(object);
+    events_group->addToGroup(object);
     return object;
 }
 
 
 void DraggablePixmapItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouse) {
     if (clicking) {
-        this->editor->selectMapObject(this, mouse->modifiers() & Qt::ControlModifier);
-        this->editor->updateSelectedObjects();
+        this->editor->selectMapEvent(this, mouse->modifiers() & Qt::ControlModifier);
+        this->editor->updateSelectedEvents();
     }
     active = false;
 }
 QList<DraggablePixmapItem *> *Editor::getObjects() {
     QList<DraggablePixmapItem *> *list = new QList<DraggablePixmapItem *>;
     for (Event *event : map->getAllEvents()) {
-        for (QGraphicsItem *child : objects_group->childItems()) {
+        for (QGraphicsItem *child : events_group->childItems()) {
             DraggablePixmapItem *item = (DraggablePixmapItem *)child;
             if (item->event == event) {
                 list->append(item);
     }
 }
 
-void Editor::updateSelectedObjects() {
+void Editor::updateSelectedEvents() {
     for (DraggablePixmapItem *item : *(getObjects())) {
         redrawObject(item);
     }
     emit selectedObjectsChanged();
 }
 
-void Editor::selectMapObject(DraggablePixmapItem *object) {
-    selectMapObject(object, false);
+void Editor::selectMapEvent(DraggablePixmapItem *object) {
+    selectMapEvent(object, false);
 }
 
-void Editor::selectMapObject(DraggablePixmapItem *object, bool toggle) {
+void Editor::selectMapEvent(DraggablePixmapItem *object, bool toggle) {
     if (selected_events && object) {
         if (selected_events->contains(object)) {
             if (toggle) {
             }
             selected_events->append(object);
         }
-        updateSelectedObjects();
+        updateSelectedEvents();
     }
 }
 
         event->put("map_name", map->name);
         event->put("event_type", event_type);
         map->addEvent(event);
-        project->loadObjectPixmaps(map->getAllEvents());
-        DraggablePixmapItem *object = addMapObject(event);
+        project->loadEventPixmaps(map->getAllEvents());
+        DraggablePixmapItem *object = addMapEvent(event);
 
         return object;
     }
                 }
                 if (deselect) {
                     selected_events->clear();
-                    updateSelectedObjects();
+                    updateSelectedEvents();
                 }
             }
         }

editor.h

     void displayMetatiles();
     void displayCollisionMetatiles();
     void displayElevationMetatiles();
-    void displayMapObjects();
+    void displayMapEvents();
     void displayMapConnections();
     void displayMapBorder();
     void displayMapGrid();
     void updateEmergeMap(QString mapName);
     void setSelectedConnectionFromMap(QString mapName);
 
-    DraggablePixmapItem *addMapObject(Event *event);
-    void selectMapObject(DraggablePixmapItem *object);
-    void selectMapObject(DraggablePixmapItem *object, bool toggle);
+    DraggablePixmapItem *addMapEvent(Event *event);
+    void selectMapEvent(DraggablePixmapItem *object);
+    void selectMapEvent(DraggablePixmapItem *object, bool toggle);
     DraggablePixmapItem *addNewEvent();
     DraggablePixmapItem *addNewEvent(QString event_type);
     void deleteEvent(Event *);
-    void updateSelectedObjects();
+    void updateSelectedEvents();
     void redrawObject(DraggablePixmapItem *item);
     QList<DraggablePixmapItem *> *getObjects();
 
     ConnectionPixmapItem* selected_connection_item = NULL;
     QList<ConnectionPixmapItem*> connection_edit_items;
     CollisionPixmapItem *collision_item = NULL;
-    QGraphicsItemGroup *objects_group = NULL;
+    QGraphicsItemGroup *events_group = NULL;
     QList<QGraphicsPixmapItem*> borderItems;
 
     QGraphicsScene *scene_metatiles = NULL;
         QList<Event*> objects;
         objects.append(event);
         event->pixmap = QPixmap();
-        editor->project->loadObjectPixmaps(objects);
+        editor->project->loadEventPixmaps(objects);
         editor->redrawObject(this);
         emit spriteChanged(event->pixmap);
     }

mainwindow.cpp

         DraggablePixmapItem *object = editor->addNewEvent();
         if (object) {
             //if (editor->selected_events->length()) {
-                editor->selectMapObject(object, true);
+                editor->selectMapEvent(object, true);
             //}
         }
         updateSelectedObjects();
         events = editor->selected_events;
     }
 
-    QMap<QString, int> map_obj_gfx_constants = editor->project->getMapObjGfxConstants();
+    QMap<QString, int> event_obj_gfx_constants = editor->project->getEventObjGfxConstants();
 
     QList<ObjectPropertiesFrame *> frames;
 
         if (event_type == "object") {
 
             frame->ui->sprite->setVisible(true);
-            frame->ui->comboBox_sprite->addItems(map_obj_gfx_constants.keys());
+            frame->ui->comboBox_sprite->addItems(event_obj_gfx_constants.keys());
             frame->ui->comboBox_sprite->setCurrentText(item->event->get("sprite"));
             connect(frame->ui->comboBox_sprite, SIGNAL(activated(QString)), item, SLOT(set_sprite(QString)));
 

project.cpp

     return names;
 }
 
-QMap<QString, int> Project::getMapObjGfxConstants() {
+QMap<QString, int> Project::getEventObjGfxConstants() {
     QMap<QString, int> constants;
-    QString text = readTextFile(root + "/include/constants/map_objects.h");
+    QString text = readTextFile(root + "/include/constants/event_objects.h");
     if (!text.isNull()) {
-        QStringList mapObjGfxPrefixes;
-        mapObjGfxPrefixes << "MAP_OBJ_GFX_";
-        constants = readCDefines(text, mapObjGfxPrefixes);
+        QStringList eventObjGfxPrefixes;
+        eventObjGfxPrefixes << "EVENT_OBJ_GFX_";
+        constants = readCDefines(text, eventObjGfxPrefixes);
     }
     return constants;
 }
     return path;
 }
 
-void Project::loadObjectPixmaps(QList<Event*> objects) {
+void Project::loadEventPixmaps(QList<Event*> objects) {
     bool needs_update = false;
     for (Event *object : objects) {
         if (object->pixmap.isNull()) {
         return;
     }
 
-    QMap<QString, int> constants = getMapObjGfxConstants();
+    QMap<QString, int> constants = getEventObjGfxConstants();
 
-    QString pointers_text = readTextFile(root + "/src/data/field_map_obj/map_object_graphics_info_pointers.h");
-    QString info_text = readTextFile(root + "/src/data/field_map_obj/map_object_graphics_info.h");
-    QString pic_text = readTextFile(root + "/src/data/field_map_obj/map_object_pic_tables.h");
-    QString assets_text = readTextFile(root + "/src/event_object_movement.c");
+    QString pointers_text = readTextFile(root + "/src/data/field_event_obj/event_object_graphics_info_pointers.h");
+    QString info_text = readTextFile(root + "/src/data/field_event_obj/event_object_graphics_info.h");
+    QString pic_text = readTextFile(root + "/src/data/field_event_obj/event_object_pic_tables.h");
+    QString assets_text = readTextFile(root + "/src/data/field_event_obj/event_object_graphics.h");
 
-    QStringList pointers = readCArray(pointers_text, "gMapObjectGraphicsInfoPointers");
+    QStringList pointers = readCArray(pointers_text, "gEventObjectGraphicsInfoPointers");
 
     for (Event *object : objects) {
         if (!object->pixmap.isNull()) {

project.h

     void readFlagNames();
     void readVarNames();
 
-    void loadObjectPixmaps(QList<Event*> objects);
-    QMap<QString, int> getMapObjGfxConstants();
+    void loadEventPixmaps(QList<Event*> objects);
+    QMap<QString, int> getEventObjGfxConstants();
     QString fixGraphicPath(QString path);
 
     void readMapEvents(Map *map);