mlc-tools. Генератор + транслятор кода. C++, Python, PHP, Java Script

Volodar
Постоялец

#0
8:03, 1 окт 2017

Название: MLC-tools
Язык: Python
Команда: Я
Github: https://github.com/mlc-tools/mlc-tools

Представляю свою утилиту для генерации и трансляции единой кодовой базы, на другие языки
Обратите внимание - утилита используется только в игровых проектах, соответственно под них и заточена.

Цели:
- Одна кодовая база для клиента и сервера
- Генерация unit-test классов, проведение тестирования
- Сериализация данных, передача их по сети между клиентом и сервером
- Хранение данных игры
- Ускорение разработки

Основной список задач:
Общее:
- Опциональная генерация классов с несколькими форматами сериализации (xml, json)
- Подключение внешних фильтров для пропуска файлов при генерации
- Подключение внешнего генератора для модификации существующих классов и добавления новых
- Для с++ используется IntrusivePtr для подсчета ссылок
- Разделение кода на client/server стороны, также разделение по языкам.
- Запуск тестового скрипта при генерации
- Возможность определения класса как inline - этот класс не будет сгенерирован, но все классы, унаследованные от него, получат весь необходимый функционал.
- Для С++ - использование non-virtual методов по возможности.
- Генерация методов для паттерна Visitor
- Генерация Observable класса для паттерна слушатель
- Слабая поддержка исключений

Классы:
- Генерация классов
- Наследование (множественное наследование не поддерживается. Есть в планах)
- Ограничение доступа (public, protected, private)
- Абстрактные классы (интерфейсы)
- Сериализация
- Генерация интерфейсов для unit тестирования публичных функций класса
- Поддержка вложенных классов

Члены класса:
- Статические
- Константные
- Стандартные типы: int, float, string
- Массивы list<item>
- Словари map<key, value>
- Инициализация по умолчанию, заданным значением
- Рантайм данные (не сериализуемые)
- Ссылки на данные

Функции:
- Поддержка const модификаторов для C++
- Тело функций пишется на с++ с ограничениями
- Абстрактные функции
- Возможность объявление external функций при поддержке в языке (не поддерживается в PHP)

Перечисления (enum):
- поддерживаются функции для перечислений
- с++ - используется тип int, конвертация в string и обратно
- Python, PHP, JS - используется string

Данные:
- объединение всех xml, json в общий файл
- поддержка ссылок на данные

Пример простой игры:
Simple Dungeon Game Online (github)

Использование сторонних библиотек для с++ кода:
1. pugixml
2. jsoncpp

Цель создания темы - поделиться наработками с народом, надеюсь будет кому-то полезна утилита.

Цель создания утилиты - давно уже заметил, что часть разработки отводится под типичные задачи, получается много кода, который похож, но выполняет различные задачи. Тогда и решил сделать генератор для таких классов. Позже к нему была прикручена сериализация, поддержка нескольких классов и т.п. Все, что делает утилита - используется и было добавлено не просто так, а по необходимости.

Документацией утилита не обладает, собираюсь в ближайшее время заняться ей. А документировать уже есть много чего.

Использование:
В данный момент утилита используется в нескольких проектах:
- Мультиплеер: Travian-подобная стратегия (не завершено)
- Сингл-плеер: Текстовый квест, Tower Defense (не завершено)
- War Alert: Red Lords. Online RTS Android iOS.
- Dungeon RPG (идет активная разработка)

В репозитории проекта лежат тесты, демонстрирующие возможности утилиты

Volodar
Постоялец

#1
8:04, 1 окт 2017

Пример конфига для генератора:

enum UnitType
{
    attack
    defend
    support
}

class data/DataUnit<SerializedObject>:storage
{
    string name
    UnitType unit_type
    VisualUnit visual
    DataUnit:link link_to_data
    list<DataUnit:link> all_units
    map<string, int> map_units
}

Генерация соответствующих классов:

+ Показать

− Скрыть

Форматирование сохранено:

+ UnitType.h

− Скрыть

#ifndef __mg_UnitType_h__
#define __mg_UnitType_h__

#include "intrusive_ptr.h"
#include "pugixml/pugixml.hpp"
#include <string>


namespace pugi
{
  class xml_node;
}
namespace mg
{
  
  class UnitType
  {
  public:
    static constexpr int attack = (1 << 0);
    static constexpr int defend = (1 << 1);
    static constexpr int support = (1 << 2);
  private:
    int value;
  public:
  public:
    UnitType();
    UnitType(int _value);
    UnitType(const UnitType& rhs);
    operator int() const;
    const UnitType& operator =(const UnitType& rhs);
    bool operator ==(const UnitType& rhs) const;
    bool operator ==(int rhs) const;
    bool operator <(const UnitType& rhs) const;
    UnitType(const std::string& _value);
    const UnitType& operator =(const std::string& _value);
    operator std::string() const;
    virtual std::string str() const;
    virtual void serialize(pugi::xml_node xml) const;
    virtual void deserialize(const pugi::xml_node& xml);
  protected:
  private:
  };
  
}//namespace mg

#endif //#ifndef __mg_UnitType_h__

− Скрыть

#include "UnitType.h"
#include "Factory.h"
#include "mg_extensions.h"
#include "pugixml/pugixml.hpp"
#include <algorithm>
#include <string>

namespace mg
{
  
  const int UnitType::attack;
  const int UnitType::defend;
  const int UnitType::support;
  
  
  UnitType::UnitType()
  {
    value = attack;
  }
  
  UnitType::UnitType(int _value)
  {
    value = _value;
  }
  
  UnitType::UnitType(const UnitType& rhs)
  {
    value = rhs.value;
  }
  
  UnitType::operator int() const
  {
    return value;
  }
  
  const UnitType& UnitType::operator =(const UnitType& rhs)
  {
    value = rhs.value;
    return *this;
  }
  
  bool UnitType::operator ==(const UnitType& rhs) const
  {
    return value == rhs.value;
  }
  
  bool UnitType::operator ==(int rhs) const
  {
    return value == rhs;
  }
  
  bool UnitType::operator <(const UnitType& rhs) const
  {
    return value < rhs.value;
  }
  
  UnitType::UnitType(const std::string& _value)
  {
    if(_value == "attack") {value = attack; return; };
    if(_value == "defend") {value = defend; return; };
    if(_value == "support") {value = support; return; };
    value = 0;
  }
  
  const UnitType& UnitType::operator =(const std::string& _value)
  {
    if(_value == "attack") {value = attack; return *this; };
    if(_value == "defend") {value = defend; return *this; };
    if(_value == "support") {value = support; return *this; };
    return *this;
  }
  
  UnitType::operator std::string() const
  {
    if(value == attack) return "attack";
    if(value == defend) return "defend";
    if(value == support) return "support";
    return "";
  }
  
  std::string UnitType::str() const
  {
    if(value == attack) return "attack";
    if(value == defend) return "defend";
    if(value == support) return "support";
    return "";
  }
  
  void UnitType::serialize(pugi::xml_node xml) const
  {
    if(value != attack)
    {
      xml.append_attribute("value").set_value(value);
    }
  }
  
  void UnitType::deserialize(const pugi::xml_node& xml)
  {
    value = xml.attribute("value").as_int(attack);
  }
  
}

− Скрыть

#ifndef __mg_DataUnit_h__
#define __mg_DataUnit_h__

#include "../SerializedObject.h"
#include "../UnitType.h"
#include "VisualUnit.h"
#include "intrusive_ptr.h"
#include "pugixml/pugixml.hpp"
#include <map>
#include <string>
#include <vector>


namespace pugi
{
  class xml_node;
}
namespace mg
{
  class Logger;
  
  class DataUnit : public SerializedObject
  {
  public:
    DataUnit();
    virtual ~DataUnit();
    
  public:
    virtual std::string get_type() const override;
    virtual void serialize(pugi::xml_node xml) const override;
    virtual void deserialize(const pugi::xml_node& xml) override;
    bool operator ==(const DataUnit& rhs) const;
    bool operator !=(const DataUnit& rhs) const;
  protected:
  private:
    
  public:
    std::string name;
    UnitType unit_type;
    VisualUnit visual;
    const DataUnit* link_to_data;
    std::vector<const DataUnit* > all_units;
    std::map<std::string, int> map_units;
    static const std::string TYPE;
  };
  
}//namespace mg

#endif //#ifndef __mg_DataUnit_h__

#include "DataUnit.h"
#include "../DataStorage.h"
#include "../Factory.h"
#include "../SerializedObject.h"
#include "../UnitType.h"
#include "../mg_extensions.h"
#include "../tests/Logger.h"
#include "DataUnit.h"
#include "VisualUnit.h"
#include "intrusive_ptr.h"
#include "pugixml/pugixml.hpp"
#include <algorithm>
#include <map>
#include <string>
#include <vector>

namespace mg
{
  const std::string DataUnit::TYPE = "DataUnit";
  REGISTRATION_OBJECT(DataUnit);
  
  DataUnit::DataUnit()
  : name("")
  , link_to_data(nullptr)
  {
    
  }
  
  DataUnit::~DataUnit()
  {
  }
  
  std::string DataUnit::get_type() const
  {
    return DataUnit::TYPE;
  }
  
  void DataUnit::serialize(pugi::xml_node xml) const
  {
    SerializedObject::serialize(xml);
    if(name != "")
    {
      xml.append_attribute("name").set_value(name.c_str());
    }
    xml.append_attribute("unit_type").set_value(unit_type.str().c_str());
    visual.serialize(xml.append_child("visual"));
    xml.append_attribute("link_to_data").set_value(link_to_data->name.c_str());
    auto arr_all_units = xml.append_child("all_units");
    for(auto& t : all_units)
    {
      arr_all_units.append_child("data").append_attribute("value").set_value(t->name.c_str());
    }
    auto map_map_units = xml.append_child("map_units");
    for(auto& pair : map_units)
    {
      auto xml = map_map_units.append_child("pair");
      auto& key = pair.first;
      auto& value = pair.second;
      xml.append_attribute("key").set_value(key.c_str());
      xml.append_attribute("value").set_value(value);
    }
  }
  
  void DataUnit::deserialize(const pugi::xml_node& xml)
  {
    SerializedObject::deserialize(xml);
    name = xml.attribute("name").as_string("");
    unit_type = std::string(xml.attribute("unit_type").as_string(""));
    visual.deserialize(xml.child("visual"));
    auto name_link_to_data = xml.attribute("link_to_data").as_string();
    link_to_data = DataStorage::shared().get<DataUnit>(name_link_to_data);
    auto arr_all_units = xml.child("all_units");
    for(auto& child : arr_all_units)
    {
      auto name = child.attribute("value").as_string("");
      all_units.push_back(DataStorage::shared().get<DataUnit>(name));
    }
    auto map_map_units = xml.child("map_units");
    for(auto child : map_map_units)
    {
      auto xml = child;
      std::string key;
      int  value;
      key = xml.attribute("key").as_string();
      value = xml.attribute("value").as_int();
      map_units[key] = value;
    }
  }
  
  bool DataUnit::operator ==(const DataUnit& rhs) const
  {
    bool result = true;
    result = result && name == rhs.name;
    result = result && unit_type == rhs.unit_type;
    result = result && visual == rhs.visual;
    result = result && all_units == rhs.all_units;
    result = result && map_units == rhs.map_units;
    return result;
  }
  
  bool DataUnit::operator !=(const DataUnit& rhs) const
  {
    return !(*this == rhs);
  }
  
}

Volodar
Постоялец

#2
8:04, 1 окт 2017

gambit_oz
Постоялец

#3
12:58, 1 окт 2017

# include "Generics.h"

ошибка вылезет

Я немного не понял суть проекта. Вот например когда я начинаю делать игру. Я беру свой движок, открываю пустой проект с этим движком и начинаю кодить.

Тут будет что то типа шаблона проекта ? типа категории - платформер, шутер, гонки - прога просто наколбасит кучу базовых классов по этим шаблонам?

Mephistopheles
Постоялец

#4
16:12, 2 окт 2017

Если я правильно понял, то чем это лучше того же protobuf?

FordPerfect
Постоялец

#5
19:10, 2 окт 2017

Двойные подчёркивания в идентификаторах, говоришь.

Madware
Постоялец

#6
9:27, 5 окт 2017

Развивай до полноценного метаязыка, будет круче :)

Madware
Постоялец

#7
9:38, 5 окт 2017

gambit_oz
> Я немного не понял суть проекта. Вот например когда я начинаю делать игру. Я
> беру свой движок, открываю пустой проект с этим движком и начинаю кодить.
>
> Тут будет что то типа шаблона проекта ? типа категории - платформер, шутер,
> гонки - прога просто наколбасит кучу базовых классов по этим шаблонам?
Насколько я понял в проге ты задаешь простые шаблоны для классов а програ генерит для них бойлерплейт типа операторов, различных конструкторов и т.д., а так же кода для сериализации/десериализации в/из xml/json

Volodar
Постоялец

#8
5:59, 29 дек 2017

Madware
> Насколько я понял в проге ты задаешь простые шаблоны для классов а програ
> генерит для них бойлерплейт типа операторов, различных конструкторов и т.д.
Все верно. Сейчас утилита умеет генерировать 3 синтаксиса - cpp, php, python. На данном этапе из коробки только в основном сериализация.
В разработке - генерация не только базовых функций, но и трансляция с++ подобного кода в остальные поддерживаемые языки.

Volodar
Постоялец

#9
15:53, 4 янв 2018

Добавил пример использования на простой мини-игры:
Simple Dungeon Game Online (github)

В игре два действия - открыть ячейку уровня и собрать золото. Оба действия обрабатываются на сервере. Клиент выступает только в качестве показа содержимого и принятия ввода от пользователя.

Чем примечателен пример - весь код игровой логики, обрабатываемой на сервере написан на c++. Для запуска на сервере код транслируется в PHP или в Python, в зависимости на каком сервере запустить игру.
Игра работает на любом из серверов (тестировалось на OS X). Сами сервера не содержат игровой логики, к примеру PHP сервер:

Сервер на C++:

+ php

#ifdef WIN32
#  include <Windows.h>
#endif
#include "HttpServer.h"
#include "utils.h"
#include "mg/DataStorage.h"
#include "mg/Request.h"
#include "mg/Factory.h"
#include "mg/config.h"
#include "pugixml/pugixml.hpp"
#include "jsoncpp/json.h"
#include <sstream>


#if MG_SERIALIZE_FORMAT == MG_JSON
std::string kDataFileName("data.json");
#else
std::string kDataFileName("data.xml");
#endif


std::string handler(const std::map<std::string, std::string>& get)
{
  if (get.count("/?request") == 0)
    return "error: cannot parse request";
  auto payload = get.at("/?request");
  
  log("\n Request: %s", payload.c_str());
  
  auto request = mg::Factory::create_command<mg::Request>(payload);
  auto response = request->execute();
  auto buffer = mg::Factory::serialize_command(response);
  
  log("Response: %s", buffer.c_str());

  return buffer;
}

int main(int argc, char **argv)
{
  std::string root;
  if(argc > 1)
    root = argv[1];

  auto buffer = getFileContent(root + kDataFileName);
  if(buffer.empty())
  {
    log("use:\n./server [path to server]\nexample:\n./server /users/user/game/server_cpp/");
    log("current path to data: %s", (root + kDataFileName).c_str());
    exit(1);
  }
  mg::DataStorage::shared().initialize(buffer);

  std::string ip("127.0.0.1");
    HttpServer server(ip, 8045);
  server.setHandler(handler);
    server.run();

  while(1)
  {
    sleep(10);
  }
  
    return 0;
}

Сервер на PHP:

+ php

− Скрыть

<?php

require_once 'mg/DataStorage.php';
require_once 'mg/config.php';
require_once 'mg/Factory.php';

function execute($request_body) {
  try {
    global $MG_SERIALIZE_FORMAT;
    global $MG_XML;

    DataStorage::$PATH_TO_DATA = $MG_SERIALIZE_FORMAT == $MG_XML?'data.xml':'data.json';

    $request  = Factory::create_command($request_body);
    $response = $request->execute();
    $response = Factory::serialize_command($response);

    echo $response;

  } catch (Exception $e) {
    echo ('error');
  }
}

$request_body = $_GET["request"];
execute($request_body)

?>

Сервер на Python:

+ python

− Скрыть

from http_server import HttpServer

from mg.DataStorage import DataStorage
from mg.Factory import Factory
from mg.config import *


class RequestHandler:

    def __init__(self, server):
        self.response = None
        self.server = server

    def handle(self, payload):
        global MG_SERIALIZE_FORMAT
        global MG_XML

        request = Factory.create_command(payload)
        response = request.execute()

        sbuffer = Factory.serialize_command(response)
        self.server.send(sbuffer)

if __name__ == '__main__':
    global MG_SERIALIZE_FORMAT
    global MG_XML

    data_file = 'data.xml' if MG_SERIALIZE_FORMAT == MG_XML else 'data.json'

    print 'run server:'
    DataStorage.shared().initialize(open(data_file).read())
    HttpServer.start(port=8045, request_handler_class=RequestHandler)

Скриншот "Игры":

+ Показать

Пока выходных много - планирую написать более сложную реализацию этой же игры, с запусками на c++, php, python серверах.

Volodar
Постоялец

#10
20:27, 4 янв 2018

Добавил к игре С++ сервер

Sh.Tac.
Удалён

#11
21:10, 4 янв 2018

так зверски оборачивать enum это постараться надо : )

а что за артефакты?

Volodar

>    if(value == "2") {_value = 2; return; };

Volodar
Постоялец

#12
6:13, 5 янв 2018

Sh.Tac.
> так зверски оборачивать enum это постараться надо : )
>
Хотелось, чтобы в xml/json, это выглядело как слово, а не цифра. После этого еще понял один крутой момент - система сообщений, когда сообщение может быть и обычный int и сложный класс, но все это дело просто сравнивается интами.

Sh.Tac.
> а что за артефакты?
Наследие старого кода. Изначально не мог подружить Python-код для нормальной десериализации, и он вместо слова, писал число. Пришлось вывертываться

Olaf85
Постоялец

#13
16:07, 23 фев 2018

Возможно я не правильно понял , но это все умеет haxe из коробки, и даже больше. Куча поддерживаемых языков + куча платформ. Правда за основу там взят не cpp, а свой флешоподобный велосипед, собсно haxe. Но любой знающий cpp в нем легко разберется. Так зачем огород городить?

Volodar
Постоялец

#14
8:24, 24 фев 2018

Olaf85
Не знал о таком. Посмотрю. По описанию с https://ru.wikipedia.org/wiki/Haxe это не то, что мне нужно было.

Страницы: 1 2 Следующая »

Тема в архиве.