void RepeatEvent::SerializeTo(SerializerElement & element) const
{
element.AddChild("repeatExpression").SetValue(repeatNumberExpression.GetPlainString());
gd::EventsListSerialization::SaveConditions(conditions, element.AddChild("conditions"));
gd::EventsListSerialization::SaveActions(actions, element.AddChild("actions"));
gd::EventsListSerialization::SerializeEventsTo(events, element.AddChild("events"));
}
void ImageResource::SerializeTo(SerializerElement & element) const
{
element.SetAttribute("alwaysLoaded", alwaysLoaded);
element.SetAttribute("smoothed", smooth);
element.SetAttribute("userAdded", IsUserAdded());
element.SetAttribute("file", GetFile()); //Keep the resource path in the current locale (but save it in UTF8 for compatibility on other OSes)
}
void ExternalEvents::UnserializeFrom(gd::Project & project, const SerializerElement & element)
{
name = element.GetStringAttribute("name", "", "Name");
associatedScene = element.GetStringAttribute("associatedLayout", "", "AssociatedScene");
lastChangeTimeStamp = element.GetIntAttribute("lastChangeTimeStamp", 0, "LastChangeTimeStamp");
gd::EventsListSerialization::UnserializeEventsFrom(project, events, element.GetChild("events", 0, "Events"));
}
void RepeatEvent::UnserializeFrom(gd::Project & project, const SerializerElement & element)
{
repeatNumberExpression = gd::Expression(element.GetChild("repeatExpression", 0, "RepeatExpression").GetValue().GetString());
gd::EventsListSerialization::OpenConditions(project, conditions, element.GetChild("conditions", 0, "Conditions"));
gd::EventsListSerialization::OpenActions(project, actions, element.GetChild("actions", 0, "Actions"));
gd::EventsListSerialization::UnserializeEventsFrom(project, events, element.GetChild("events", 0, "Events"));
}
void ImageResource::SerializeTo(SerializerElement & element) const
{
element.SetAttribute("alwaysLoaded", alwaysLoaded);
element.SetAttribute("smoothed", smooth);
element.SetAttribute("userAdded", IsUserAdded());
element.SetAttribute("file", GetFile());
}
void ExternalEvents::SerializeTo(SerializerElement & element) const
{
element.SetAttribute("name", name);
element.SetAttribute("associatedLayout", associatedScene);
element.SetAttribute("lastChangeTimeStamp", (int)lastChangeTimeStamp);
gd::EventsListSerialization::SerializeEventsTo(events, element.AddChild("events"));
}
void AnalyticsSender::SendData(gd::String collection, SerializerElement & data)
{
#if !defined(GD_NO_WX_GUI)
//Check if we are allowed to send these data.
bool sendInfo;
wxConfigBase::Get()->Read("/Startup/SendInfo", &sendInfo, true);
if (!sendInfo) return;
data.SetAttribute("gdVersion", VersionWrapper::FullString());
data.SetAttribute("os", gd::String(wxGetOsDescription()));
data.SetAttribute("lang",
gd::String(wxLocale::GetLanguageCanonicalName(LocaleManager::Get()->GetLanguage())));
if (wxConfig::Get())
data.SetAttribute("openingCount", wxConfig::Get()->ReadDouble("Startup/OpeningCount", 0));
// Create request
std::cout << "Sending analytics data..."; std::cout.flush();
sf::Http Http;
Http.setHost("http://api.keen.io");
sf::Http::Request request;
request.setMethod(sf::Http::Request::Post);
request.setField("Content-Type", "application/json");
request.setUri("/3.0/projects/"+projectId.ToLocale()+"/events/"+collection.ToLocale()+"?api_key="+writeKey.ToLocale());
request.setBody(Serializer::ToJSON(data).ToSfString());
// Send the request
sf::Http::Response response = Http.sendRequest(request, sf::seconds(2));
std::cout << "done (" << response.getStatus() << ")" << std::endl;
#endif
}
void Layer::SerializeTo(SerializerElement& element) const {
element.SetAttribute("name", GetName());
element.SetAttribute("visibility", GetVisibility());
SerializerElement& camerasElement = element.AddChild("cameras");
camerasElement.ConsiderAsArrayOf("camera");
for (std::size_t c = 0; c < GetCameraCount(); ++c) {
SerializerElement& cameraElement = camerasElement.AddChild("camera");
cameraElement.SetAttribute("defaultSize", GetCamera(c).UseDefaultSize());
cameraElement.SetAttribute("width", GetCamera(c).GetWidth());
cameraElement.SetAttribute("height", GetCamera(c).GetHeight());
cameraElement.SetAttribute("defaultViewport",
GetCamera(c).UseDefaultViewport());
cameraElement.SetAttribute("viewportLeft", GetCamera(c).GetViewportX1());
cameraElement.SetAttribute("viewportTop", GetCamera(c).GetViewportY1());
cameraElement.SetAttribute("viewportRight", GetCamera(c).GetViewportX2());
cameraElement.SetAttribute("viewportBottom", GetCamera(c).GetViewportY2());
}
SerializerElement& effectsElement = element.AddChild("effects");
effectsElement.ConsiderAsArrayOf("effect");
for (std::size_t i = 0; i < GetEffectsCount(); ++i) {
SerializerElement& effectElement = effectsElement.AddChild("effect");
GetEffect(i).SerializeTo(effectElement);
}
}
std::vector<Splitter::SplitElement> Splitter::Split(
SerializerElement& element,
const std::set<gd::String>& tags,
gd::String path) {
std::vector<Splitter::SplitElement> elements;
for (auto& child : element.GetAllChildren()) {
auto& childElement = child.second;
gd::String ref = path + pathSeparator + child.first;
if (tags.find(ref) != tags.end()) {
gd::String refName = childElement->GetStringAttribute(nameAttribute);
SplitElement splitElement = {ref, refName, *childElement};
elements.push_back(splitElement);
SerializerElement refElement;
refElement.SetAttribute("referenceTo", ref);
refElement.SetAttribute("name", refName);
*childElement = refElement;
} else {
auto newElements = Split(*childElement, tags, ref);
elements.insert(elements.end(), newElements.begin(), newElements.end());
}
}
return elements;
}
void ObjectGroup::UnserializeFrom(std::vector < gd::ObjectGroup > & list, const SerializerElement & element)
{
element.ConsiderAsArrayOf("group", "Groupe");
for (unsigned int i = 0; i < element.GetChildrenCount(); ++i)
{
SerializerElement & groupElement = element.GetChild(i);
gd::ObjectGroup objectGroup;
objectGroup.SetName(groupElement.GetStringAttribute("name", "", "nom"));
//Compatibility with GD <= 3.3
if ( groupElement.HasChild("Objet") )
{
for (unsigned int j = 0; j < groupElement.GetChildrenCount("Objet"); ++j)
objectGroup.AddObject(groupElement.GetChild("Objet", j).GetStringAttribute("nom"));
}
//End of compatibility code
else
{
SerializerElement & objectsElement = groupElement.GetChild("objects");
objectsElement.ConsiderAsArrayOf("object");
for (unsigned int j = 0; j < objectsElement.GetChildrenCount(); ++j)
objectGroup.AddObject(objectsElement.GetChild(j).GetStringAttribute("name"));
}
list.push_back( objectGroup );
}
}
void ResourcesManager::UnserializeFrom(const SerializerElement & element)
{
const SerializerElement & resourcesElement = element.GetChild("resources", 0, "Resources");
resourcesElement.ConsiderAsArrayOf("resource", "Resource");
for(std::size_t i = 0;i<resourcesElement.GetChildrenCount();++i)
{
const SerializerElement & resourceElement = resourcesElement.GetChild(i);
gd::String kind = resourceElement.GetStringAttribute("kind");
gd::String name = resourceElement.GetStringAttribute("name");
std::shared_ptr<Resource> resource = CreateResource(kind);
resource->SetName(name);
resource->UnserializeFrom(resourceElement);
resources.push_back(resource);
}
#if defined(GD_IDE_ONLY)
const SerializerElement & resourcesFoldersElement = element.GetChild("resourceFolders", 0, "ResourceFolders");
resourcesFoldersElement.ConsiderAsArrayOf("folder", "Folder");
for(std::size_t i = 0;i<resourcesFoldersElement.GetChildrenCount();++i)
{
ResourceFolder folder;
folder.UnserializeFrom(resourcesFoldersElement.GetChild(i), *this);
folders.push_back(folder);
}
#endif
}
void ImageResource::UnserializeFrom(const SerializerElement & element)
{
alwaysLoaded = element.GetBoolAttribute("alwaysLoaded");
smooth = element.GetBoolAttribute("smoothed");
SetUserAdded( element.GetBoolAttribute("userAdded") );
SetFile(element.GetStringAttribute("file"));
}
void LinkEvent::UnserializeFrom(gd::Project & project, const SerializerElement & element)
{
SerializerElement & includeElement = element.GetChild("include", 0, "Limites");
SetTarget(element.GetChild("target", 0, "Scene").GetValue().GetString());
if(includeElement.HasAttribute("includeAll"))
{
//Compatibility with GDevelop <= 4.0.92
if(includeElement.GetBoolAttribute("includeAll", true))
{
SetIncludeAllEvents();
}
else
{
SetIncludeStartAndEnd(includeElement.GetIntAttribute("start"),
includeElement.GetIntAttribute("end"));
}
}
else
{
//GDevelop > 4.0.92
IncludeConfig config = static_cast<IncludeConfig>(includeElement.GetIntAttribute("includeConfig", 0));
if(config == INCLUDE_ALL)
SetIncludeAllEvents();
else if(config == INCLUDE_EVENTS_GROUP)
SetIncludeEventsGroup(includeElement.GetStringAttribute("eventsGroup"));
else if(config == INCLUDE_BY_INDEX)
SetIncludeStartAndEnd(includeElement.GetIntAttribute("start"), includeElement.GetIntAttribute("end"));
}
}
void ForEachEvent::UnserializeFrom(gd::Project & project, const SerializerElement & element)
{
objectsToPick = gd::Expression(element.GetChild("object", 0, "Object").GetValue().GetString());
gd::EventsListSerialization::OpenConditions(project, conditions, element.GetChild("conditions", 0, "Conditions"));
gd::EventsListSerialization::OpenActions(project, actions, element.GetChild("actions", 0, "Actions"));
gd::EventsListSerialization::UnserializeEventsFrom(project, events, element.GetChild("events", 0, "Events"));
}
void ForEachEvent::SerializeTo(SerializerElement & element) const
{
element.AddChild("object").SetValue(objectsToPick.GetPlainString());
gd::EventsListSerialization::SaveConditions(conditions, element.AddChild("conditions"));
gd::EventsListSerialization::SaveActions(actions, element.AddChild("actions"));
gd::EventsListSerialization::SerializeEventsTo(events, element.AddChild("events"));
}
void WhileEvent::SerializeTo(SerializerElement & element) const
{
element.SetAttribute("infiniteLoopWarning", infiniteLoopWarning);
gd::EventsListSerialization::SaveConditions(whileConditions, element.AddChild("whileConditions"));
gd::EventsListSerialization::SaveConditions(conditions, element.AddChild("conditions"));
gd::EventsListSerialization::SaveActions(actions, element.AddChild("actions"));
gd::EventsListSerialization::SerializeEventsTo(events, element.AddChild("events"));
}
void LinkEvent::UnserializeFrom(gd::Project & project, const SerializerElement & element)
{
SerializerElement & includeElement = element.GetChild("include", 0, "Limites");
SetIncludeStartAndEnd(includeElement.GetIntAttribute("start"),
includeElement.GetIntAttribute("end"));
SetIncludeAllEvents(includeElement.GetBoolAttribute("includeAll", true));
SetTarget(element.GetChild("target", 0, "Scene").GetValue().GetString());
}
void WhileEvent::UnserializeFrom(gd::Project & project, const SerializerElement & element)
{
justCreatedByTheUser = false;
infiniteLoopWarning = element.GetBoolAttribute("infiniteLoopWarning");
gd::EventsListSerialization::OpenConditions(project, whileConditions, element.GetChild("whileConditions", 0, "WhileConditions"));
gd::EventsListSerialization::OpenConditions(project, conditions, element.GetChild("conditions", 0, "Conditions"));
gd::EventsListSerialization::OpenActions(project, actions, element.GetChild("actions", 0, "Actions"));
gd::EventsListSerialization::UnserializeEventsFrom(project, events, element.GetChild("events", 0, "Events"));
}
void ClassWithObjects::SerializeObjectsTo(SerializerElement & element) const
{
element.ConsiderAsArrayOf("object");
for ( std::size_t j = 0;j < initialObjects.size();j++ )
{
initialObjects[j]->SerializeTo(element.AddChild("object"));
}
}
void ExternalLayout::SerializeTo(SerializerElement & element) const
{
element.SetAttribute("name", name);
instances.SerializeTo(element.AddChild("instances"));
#if !defined(GD_NO_WX_GUI)
editionSettings.SerializeTo(element.AddChild("editionSettings"));
element.SetAttribute("associatedLayout", associatedLayout);
#endif
}
void LinkEvent::SerializeTo(SerializerElement & element) const
{
element.AddChild("include")
.SetAttribute("includeAll", IncludeAllEvents())
.SetAttribute("start", (int)GetIncludeStart())
.SetAttribute("end", (int)GetIncludeEnd());
element.AddChild("target").SetValue(GetTarget());
}
void ResourceFolder::UnserializeFrom(const SerializerElement & element, gd::ResourcesManager & parentManager)
{
name = element.GetStringAttribute("name");
SerializerElement & resourcesElement = element.GetChild("resources", 0, "Resources");
resourcesElement.ConsiderAsArrayOf("resource", "Resource");
for(std::size_t i = 0;i<resourcesElement.GetChildrenCount();++i)
AddResource(resourcesElement.GetChild(i).GetStringAttribute("name"), parentManager);
}
void ExternalLayout::UnserializeFrom(const SerializerElement & element)
{
name = element.GetStringAttribute("name", "", "Name");
instances.UnserializeFrom(element.GetChild("instances", 0, "Instances"));
#if defined(GD_IDE_ONLY) && !defined(GD_NO_WX_GUI)
editionSettings.UnserializeFrom(element.GetChild("editionSettings"));
associatedLayout = element.GetStringAttribute("associatedLayout");
#endif
}
void Object::UnserializeFrom(gd::Project & project, const SerializerElement & element)
{
//Name and type are already loaded.
objectVariables.UnserializeFrom(element.GetChild("variables", 0, "Variables"));
//Compatibility with GD <= 3.3
if (element.HasChild("Automatism"))
{
for (std::size_t i = 0; i < element.GetChildrenCount("Automatism"); ++i)
{
SerializerElement & behaviorElement = element.GetChild("Automatism", i);
gd::String autoType = behaviorElement.GetStringAttribute("type", "", "Type")
.FindAndReplace("Automatism", "Behavior");
gd::String autoName = behaviorElement.GetStringAttribute("name", "", "Name");
Behavior* behavior = project.CreateBehavior(autoType);
if ( behavior != NULL )
{
behavior->SetName(autoName);
behavior->UnserializeFrom(behaviorElement);
behaviors[behavior->GetName()] = behavior;
}
else
std::cout << "WARNING: Unknown behavior " << autoType << std::endl;
}
}
//End of compatibility code
else
{
SerializerElement & behaviorsElement = element.GetChild("behaviors", 0, "automatisms");
behaviorsElement.ConsiderAsArrayOf("behavior", "automatism");
for (std::size_t i = 0; i < behaviorsElement.GetChildrenCount(); ++i)
{
SerializerElement & behaviorElement = behaviorsElement.GetChild(i);
gd::String autoType = behaviorElement.GetStringAttribute("type")
.FindAndReplace("Automatism", "Behavior"); //Compatibility with GD <= 4
gd::String autoName = behaviorElement.GetStringAttribute("name");
Behavior* behavior = project.CreateBehavior(autoType);
if ( behavior != NULL )
{
behavior->SetName(autoName);
behavior->UnserializeFrom(behaviorElement);
behaviors[behavior->GetName()] = behavior;
}
else
std::cout << "WARNING: Unknown behavior " << autoType << std::endl;
}
}
DoUnserializeFrom(project, element);
}
void ResourceFolder::SerializeTo(SerializerElement & element) const
{
element.SetAttribute("name", name);
SerializerElement & resourcesElement = element.AddChild("resources");
resourcesElement.ConsiderAsArrayOf("resource");
for (std::size_t i = 0;i<resources.size();++i)
{
if ( resources[i] == std::shared_ptr<Resource>() ) continue;
resourcesElement.AddChild("resource").SetAttribute("name", resources[i]->GetName());
}
}
void AnalyticsSender::SendNewGameCreated(gd::String platformName, gd::String templateName)
{
#if !defined(GD_NO_WX_GUI)
wxFileName templateFile = wxFileName::FileName(templateName);
templateFile.MakeRelativeTo();
SerializerElement data;
data.SetAttribute("platform", platformName);
data.SetAttribute("templateName", gd::String(templateFile.GetFullPath(wxPATH_UNIX)));
SendData("new_game_creation", data);
#endif
}
void CommentEvent::SerializeTo(SerializerElement & element) const
{
element.AddChild("color")
.SetAttribute("r", r)
.SetAttribute("g", v)
.SetAttribute("b", b)
.SetAttribute("textR", textR)
.SetAttribute("textG", textG)
.SetAttribute("textB", textB);
element.AddChild("comment").SetValue(com1);
element.AddChild("comment2").SetValue(com2);
}
void CommentEvent::UnserializeFrom(gd::Project & project, const SerializerElement & element)
{
const SerializerElement & colorElement = element.GetChild("color", 0, "Couleur");
r = colorElement.GetIntAttribute("r");
v = colorElement.GetIntAttribute("g", 0, "v");
b = colorElement.GetIntAttribute("b");
textR = colorElement.GetIntAttribute("textR");
textG = colorElement.GetIntAttribute("textG");
textB = colorElement.GetIntAttribute("textB");
com1 = element.GetChild("comment", 0, "Com1").GetValue().GetString();
com2 = element.GetChild("comment2", 0, "Com2").GetValue().GetString();
}
void EventsListSerialization::SerializeEventsTo(const EventsList & list, SerializerElement & events)
{
events.ConsiderAsArrayOf("event");
for ( unsigned int j = 0;j < list.size();j++ )
{
const gd::BaseEvent & event = list.GetEvent(j);
SerializerElement & eventElem = events.AddChild("event");
eventElem.SetAttribute( "disabled", event.IsDisabled());
eventElem.SetAttribute( "folded", event.folded);
eventElem.AddChild("type").SetValue(event.GetType());
event.SerializeTo(eventElem);
}
}
void ObjectGroup::SerializeTo(const std::vector < gd::ObjectGroup > & list, SerializerElement & element)
{
element.ConsiderAsArrayOf("group");
for ( unsigned int j = 0;j < list.size();j++ )
{
SerializerElement & groupElement = element.AddChild("group");
groupElement.SetAttribute("name", list[j].GetName());
SerializerElement & objectsElement = groupElement.AddChild("objects");
objectsElement.ConsiderAsArrayOf("object");
vector < string > allObjects = list[j].GetAllObjectsNames();
for ( unsigned int k = 0;k < allObjects.size();k++ )
objectsElement.AddChild("object").SetAttribute( "name", allObjects[k] );
}
}
