protected override void FillNode(XmlNode node, object target, params IDOMWriterParam[] options)
        {
            var item = target as Item;

            XmlElement itemElement = node as XmlElement;


            // Create the necessary elements to create the DOM
            XmlDocument doc = Writer.GetDoc();

            // Create the root node
            itemElement.SetAttribute("id", item.getId());
            itemElement.SetAttribute("returnsWhenDragged", (item.isReturnsWhenDragged() ? "yes" : "no"));

            //v1.4
            if (item.getBehaviour() == Item.BehaviourType.NORMAL)
            {
                itemElement.SetAttribute("behaviour", "normal");
            }
            if (item.getBehaviour() == Item.BehaviourType.ATREZZO)
            {
                itemElement.SetAttribute("behaviour", "atrezzo");
            }
            if (item.getBehaviour() == Item.BehaviourType.FIRST_ACTION)
            {
                itemElement.SetAttribute("behaviour", "first-action");
            }
            itemElement.SetAttribute("resources-transition-time", item.getResourcesTransitionTime().ToString());
            //v1.4

            // Append the documentation (if avalaible)
            if (item.getDocumentation() != null)
            {
                XmlNode itemDocumentationNode = doc.CreateElement("documentation");
                itemDocumentationNode.AppendChild(doc.CreateTextNode(item.getDocumentation()));
                itemElement.AppendChild(itemDocumentationNode);
            }

            // Append the resources
            foreach (ResourcesUni resources in item.getResources())
            {
                XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_ITEM);
                doc.ImportNode(resourcesNode, true);
                itemElement.AppendChild(resourcesNode);
            }

            DOMWriterUtility.DOMWrite(itemElement, item.getDescriptions());

            // Append the actions (if there is at least one)
            if (item.getActions().Count > 0)
            {
                // Create the actions node
                DOMWriterUtility.DOMWrite(itemElement, item.getActions());
            }
        }
        protected override void FillNode(XmlNode node, object target, params IDOMWriterParam[] options)
        {
            var sceneElement = node as XmlElement;
            var scene        = target as Scene;

            if (scene != null)
            {
                TrajectoryFixer.fixTrajectory(scene);
            }
            // Create the necessary elements to create the DOM
            XmlDocument doc = Writer.GetDoc();

            // Create the root node
            sceneElement.SetAttribute("id", scene.getId());
            sceneElement.SetAttribute("hideInventory", scene.HideInventory ? "yes" : "no");

            if (options.Any(o => o is CIP && (o as CIP).TargetId.Equals(scene.getId())))
            {
                sceneElement.SetAttribute("start", "yes");
            }
            else
            {
                sceneElement.SetAttribute("start", "no");
            }

            sceneElement.SetAttribute("playerLayer", scene.getPlayerLayer().ToString());
            sceneElement.SetAttribute("playerScale", scene.getPlayerScale().ToString(CultureInfo.InvariantCulture));

            sceneElement.SetAttribute("class", scene.getXApiClass());
            sceneElement.SetAttribute("type", scene.getXApiType());

            // Append the documentation (if avalaible)
            if (scene.getDocumentation() != null)
            {
                XmlNode sceneDocumentationNode = doc.CreateElement("documentation");
                sceneDocumentationNode.AppendChild(doc.CreateTextNode(scene.getDocumentation()));
                sceneElement.AppendChild(sceneDocumentationNode);
            }

            // Append the resources
            foreach (ResourcesUni resources in scene.getResources())
            {
                XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_SCENE);
                doc.ImportNode(resourcesNode, true);
                sceneElement.AppendChild(resourcesNode);
            }

            // Append the name
            XmlNode nameNode = doc.CreateElement("name");

            nameNode.AppendChild(doc.CreateTextNode(scene.getName()));
            sceneElement.AppendChild(nameNode);

            // Append the default inital position (if avalaible)
            if (scene.hasDefaultPosition())
            {
                XmlElement initialPositionElement = doc.CreateElement("default-initial-position");
                initialPositionElement.SetAttribute("x", scene.getPositionX().ToString());
                initialPositionElement.SetAttribute("y", scene.getPositionY().ToString());
                sceneElement.AppendChild(initialPositionElement);
            }

            // Append the exits (if there is at least one)
            if (scene.getExits().Count > 0)
            {
                XmlNode exitsElement = doc.CreateElement("exits");

                // Append every single exit
                foreach (Exit exit in scene.getExits())
                {
                    // Create the exit element
                    XmlElement exitElement = doc.CreateElement("exit");
                    exitElement.SetAttribute("rectangular", (exit.isRectangular() ? "yes" : "no"));
                    exitElement.SetAttribute("x", exit.getX().ToString());
                    exitElement.SetAttribute("y", exit.getY().ToString());
                    exitElement.SetAttribute("width", exit.getWidth().ToString());
                    exitElement.SetAttribute("height", exit.getHeight().ToString());
                    exitElement.SetAttribute("hasInfluenceArea", (exit.getInfluenceArea().isExists() ? "yes" : "no"));
                    exitElement.SetAttribute("idTarget", exit.getNextSceneId());
                    exitElement.SetAttribute("destinyY", exit.getDestinyY().ToString());
                    exitElement.SetAttribute("destinyX", exit.getDestinyX().ToString());
                    if (exit.getDestinyScale() >= 0)
                    {
                        exitElement.SetAttribute("destinyScale", exit.getDestinyScale().ToString(CultureInfo.InvariantCulture));
                    }
                    exitElement.SetAttribute("transitionType", exit.getTransitionType().ToString());
                    exitElement.SetAttribute("transitionTime", exit.getTransitionTime().ToString());
                    exitElement.SetAttribute("not-effects", (exit.isHasNotEffects() ? "yes" : "no"));

                    if (exit.getInfluenceArea().isExists())
                    {
                        exitElement.SetAttribute("influenceX", exit.getInfluenceArea().getX().ToString());
                        exitElement.SetAttribute("influenceY", exit.getInfluenceArea().getY().ToString());
                        exitElement.SetAttribute("influenceWidth", exit.getInfluenceArea().getWidth().ToString());
                        exitElement.SetAttribute("influenceHeight", exit.getInfluenceArea().getHeight().ToString());
                    }

                    // Append the documentation (if avalaible)
                    if (exit.getDocumentation() != null)
                    {
                        XmlNode exitDocumentationNode = doc.CreateElement("documentation");
                        exitDocumentationNode.AppendChild(doc.CreateTextNode(exit.getDocumentation()));
                        exitElement.AppendChild(exitDocumentationNode);
                    }

                    //Append the default exit look (if available)
                    ExitLook defaultLook = exit.getDefaultExitLook();
                    if (defaultLook != null)
                    {
                        XmlElement exitLook = doc.CreateElement("exit-look");
                        if (defaultLook.getExitText() != null)
                        {
                            exitLook.SetAttribute("text", defaultLook.getExitText());
                        }
                        if (defaultLook.getCursorPath() != null)
                        {
                            exitLook.SetAttribute("cursor-path", defaultLook.getCursorPath());
                        }
                        if (defaultLook.getSoundPath() != null)
                        {
                            exitLook.SetAttribute("sound-path", defaultLook.getSoundPath());
                        }

                        if (defaultLook.getExitText() != null || defaultLook.getCursorPath() != null)
                        {
                            exitElement.AppendChild(exitLook);
                        }
                    }

                    // Append the next-scene structures
                    foreach (NextScene nextScene in exit.getNextScenes())
                    {
                        // Create the next-scene element
                        XmlElement nextSceneElement = doc.CreateElement("next-scene");
                        nextSceneElement.SetAttribute("idTarget", nextScene.getTargetId());

                        // Append the destination position (if avalaible)
                        if (nextScene.hasPlayerPosition())
                        {
                            nextSceneElement.SetAttribute("x", nextScene.getPositionX().ToString());
                            nextSceneElement.SetAttribute("y", nextScene.getPositionY().ToString());
                        }

                        nextSceneElement.SetAttribute("transitionTime", nextScene.getTransitionTime().ToString());
                        nextSceneElement.SetAttribute("transitionType", nextScene.getTransitionType().ToString());

                        // Append the conditions (if avalaible)
                        if (!nextScene.getConditions().IsEmpty())
                        {
                            DOMWriterUtility.DOMWrite(nextSceneElement, nextScene.getConditions());
                        }

                        //Append the default exit look (if available)
                        ExitLook look = nextScene.getExitLook();
                        if (look != null)
                        {
                            Debug.Log("SAVE 154: " + look.getExitText());
                            XmlElement exitLook = doc.CreateElement("exit-look");
                            if (look.getExitText() != null)
                            {
                                exitLook.SetAttribute("text", look.getExitText());
                            }
                            if (look.getCursorPath() != null)
                            {
                                exitLook.SetAttribute("cursor-path", look.getCursorPath());
                            }
                            if (look.getSoundPath() != null)
                            {
                                exitLook.SetAttribute("sound-path", look.getSoundPath());
                            }
                            if (look.getExitText() != null || look.getCursorPath() != null)
                            {
                                nextSceneElement.AppendChild(exitLook);
                            }
                        }

                        OrderedDictionary nextSceneEffects = new OrderedDictionary();

                        if (nextScene.getEffects() != null && !nextScene.getEffects().IsEmpty())
                        {
                            nextSceneEffects.Add(EffectsDOMWriter.EFFECTS, nextScene.getEffects());
                        }

                        if (nextScene.getPostEffects() != null && !nextScene.getPostEffects().IsEmpty())
                        {
                            nextSceneEffects.Add(EffectsDOMWriter.POST_EFFECTS, nextScene.getPostEffects());
                        }

                        // Append the next scene
                        DOMWriterUtility.DOMWrite(nextSceneElement, nextSceneEffects, DOMWriterUtility.DontCreateElement());

                        exitElement.AppendChild(nextSceneElement);
                    }

                    if (!exit.isRectangular())
                    {
                        foreach (Vector2 point in exit.getPoints())
                        {
                            XmlElement pointNode = doc.CreateElement("point");
                            pointNode.SetAttribute("x", ((int)point.x).ToString());
                            pointNode.SetAttribute("y", ((int)point.y).ToString());
                            exitElement.AppendChild(pointNode);
                        }
                    }

                    if (exit.getConditions() != null && !exit.getConditions().IsEmpty())
                    {
                        DOMWriterUtility.DOMWrite(exitElement, exit.getConditions());
                    }

                    OrderedDictionary effectsTypes = new OrderedDictionary();

                    if (exit.getEffects() != null && !exit.getEffects().IsEmpty())
                    {
                        effectsTypes.Add(EffectsDOMWriter.EFFECTS, exit.getEffects());
                    }

                    if (exit.getPostEffects() != null && !exit.getPostEffects().IsEmpty())
                    {
                        effectsTypes.Add(EffectsDOMWriter.POST_EFFECTS, exit.getPostEffects());
                    }

                    if (exit.getNotEffects() != null && !exit.getNotEffects().IsEmpty())
                    {
                        effectsTypes.Add(EffectsDOMWriter.NOT_EFFECTS, exit.getNotEffects());
                    }


                    DOMWriterUtility.DOMWrite(exitElement, effectsTypes, DOMWriterUtility.DontCreateElement());

                    // Append the exit
                    exitsElement.AppendChild(exitElement);
                }
                // Append the list of exits
                sceneElement.AppendChild(exitsElement);
            }

            // Add the item references (if there is at least one)
            if (scene.getItemReferences().Count > 0)
            {
                XmlNode itemsNode = doc.CreateElement("objects");

                // Append every single item reference
                foreach (ElementReference itemReference in scene.getItemReferences())
                {
                    // Create the item reference element
                    XmlElement itemReferenceElement = doc.CreateElement("object-ref");
                    itemReferenceElement.SetAttribute("idTarget", itemReference.getTargetId());
                    itemReferenceElement.SetAttribute("x", itemReference.getX().ToString());
                    itemReferenceElement.SetAttribute("y", itemReference.getY().ToString());
                    itemReferenceElement.SetAttribute("scale", itemReference.Scale.ToString(CultureInfo.InvariantCulture));
                    if (itemReference.getLayer() != -1)
                    {
                        itemReferenceElement.SetAttribute("layer", itemReference.getLayer().ToString());
                    }
                    if (itemReference.getInfluenceArea().isExists())
                    {
                        itemReferenceElement.SetAttribute("hasInfluenceArea", "yes");
                        InfluenceArea ia = itemReference.getInfluenceArea();
                        itemReferenceElement.SetAttribute("influenceX", ia.getX().ToString());
                        itemReferenceElement.SetAttribute("influenceY", ia.getY().ToString());
                        itemReferenceElement.SetAttribute("influenceWidth", ia.getWidth().ToString());
                        itemReferenceElement.SetAttribute("influenceHeight", ia.getHeight().ToString());
                    }
                    else
                    {
                        itemReferenceElement.SetAttribute("hasInfluenceArea", "no");
                    }

                    // Append the documentation (if avalaible)
                    if (itemReference.getDocumentation() != null)
                    {
                        XmlNode itemDocumentationNode = doc.CreateElement("documentation");
                        itemDocumentationNode.AppendChild(doc.CreateTextNode(itemReference.getDocumentation()));
                        itemReferenceElement.AppendChild(itemDocumentationNode);
                    }

                    // Append the conditions (if avalaible)
                    if (!itemReference.Conditions.IsEmpty())
                    {
                        DOMWriterUtility.DOMWrite(itemReferenceElement, itemReference.Conditions);
                    }

                    // Append the exit
                    itemsNode.AppendChild(itemReferenceElement);
                }
                // Append the list of exits
                sceneElement.AppendChild(itemsNode);
            }

            // Add the character references (if there is at least one)
            if (scene.getCharacterReferences().Count > 0)
            {
                XmlNode charactersNode = doc.CreateElement("characters");

                // Append every single character reference
                foreach (ElementReference characterReference in scene.getCharacterReferences())
                {
                    // Create the character reference element
                    XmlElement npcReferenceElement = doc.CreateElement("character-ref");
                    npcReferenceElement.SetAttribute("idTarget", characterReference.getTargetId());
                    npcReferenceElement.SetAttribute("x", characterReference.getX().ToString());
                    npcReferenceElement.SetAttribute("y", characterReference.getY().ToString());
                    npcReferenceElement.SetAttribute("scale", characterReference.Scale.ToString(CultureInfo.InvariantCulture));
                    npcReferenceElement.SetAttribute("orientation", ((int)characterReference.Orientation).ToString());
                    if (characterReference.getLayer() != -1)
                    {
                        npcReferenceElement.SetAttribute("layer", characterReference.getLayer().ToString());
                    }
                    if (characterReference.getInfluenceArea().isExists())
                    {
                        npcReferenceElement.SetAttribute("hasInfluenceArea", "yes");
                        InfluenceArea ia = characterReference.getInfluenceArea();
                        npcReferenceElement.SetAttribute("influenceX", ia.getX().ToString());
                        npcReferenceElement.SetAttribute("influenceY", ia.getY().ToString());
                        npcReferenceElement.SetAttribute("influenceWidth", ia.getWidth().ToString());
                        npcReferenceElement.SetAttribute("influenceHeight", ia.getHeight().ToString());
                    }
                    else
                    {
                        npcReferenceElement.SetAttribute("hasInfluenceArea", "no");
                    }

                    // Append the documentation (if avalaible)
                    if (characterReference.getDocumentation() != null)
                    {
                        XmlNode itemDocumentationNode = doc.CreateElement("documentation");
                        itemDocumentationNode.AppendChild(doc.CreateTextNode(characterReference.getDocumentation()));
                        npcReferenceElement.AppendChild(itemDocumentationNode);
                    }

                    // Append the conditions (if avalaible)
                    if (!characterReference.Conditions.IsEmpty())
                    {
                        DOMWriterUtility.DOMWrite(npcReferenceElement, characterReference.Conditions);
                    }

                    // Append the exit
                    charactersNode.AppendChild(npcReferenceElement);
                }
                // Append the list of exits
                sceneElement.AppendChild(charactersNode);
            }

            // Append the exits (if there is at least one)
            if (scene.getActiveAreas().Count > 0)
            {
                XmlNode aasElement = doc.CreateElement("active-areas");

                // Append every single exit
                foreach (ActiveArea activeArea in scene.getActiveAreas())
                {
                    // Create the active area element
                    XmlElement aaElement = doc.CreateElement("active-area");
                    if (activeArea.getId() != null)
                    {
                        aaElement.SetAttribute("id", activeArea.getId());
                    }
                    aaElement.SetAttribute("rectangular", (activeArea.isRectangular() ? "yes" : "no"));
                    aaElement.SetAttribute("x", activeArea.getX().ToString());
                    aaElement.SetAttribute("y", activeArea.getY().ToString());
                    aaElement.SetAttribute("width", activeArea.getWidth().ToString());
                    aaElement.SetAttribute("height", activeArea.getHeight().ToString());
                    if (activeArea.getInfluenceArea().isExists())
                    {
                        aaElement.SetAttribute("hasInfluenceArea", "yes");
                        InfluenceArea ia = activeArea.getInfluenceArea();
                        aaElement.SetAttribute("influenceX", ia.getX().ToString());
                        aaElement.SetAttribute("influenceY", ia.getY().ToString());
                        aaElement.SetAttribute("influenceWidth", ia.getWidth().ToString());
                        aaElement.SetAttribute("influenceHeight", ia.getHeight().ToString());
                    }
                    else
                    {
                        aaElement.SetAttribute("hasInfluenceArea", "no");
                    }

                    // Behavior
                    if (activeArea.getBehaviour() == Item.BehaviourType.NORMAL)
                    {
                        aaElement.SetAttribute("behaviour", "normal");
                    }
                    if (activeArea.getBehaviour() == Item.BehaviourType.ATREZZO)
                    {
                        aaElement.SetAttribute("behaviour", "atrezzo");
                    }
                    if (activeArea.getBehaviour() == Item.BehaviourType.FIRST_ACTION)
                    {
                        aaElement.SetAttribute("behaviour", "first-action");
                    }

                    // Append the documentation (if avalaible)
                    if (activeArea.getDocumentation() != null)
                    {
                        XmlNode exitDocumentationNode = doc.CreateElement("documentation");
                        exitDocumentationNode.AppendChild(doc.CreateTextNode(activeArea.getDocumentation()));
                        aaElement.AppendChild(exitDocumentationNode);
                    }

                    // Append the conditions (if avalaible)
                    if (!activeArea.getConditions().IsEmpty())
                    {
                        DOMWriterUtility.DOMWrite(aaElement, activeArea.getConditions());
                    }


                    foreach (Description description in activeArea.getDescriptions())
                    {
                        // Create the description
                        XmlNode descriptionNode = doc.CreateElement("description");

                        // Append the conditions (if available)
                        if (description.getConditions() != null && !description.getConditions().IsEmpty())
                        {
                            DOMWriterUtility.DOMWrite(descriptionNode, description.getConditions());
                        }

                        // Create and append the name, brief description and detailed description
                        XmlElement aaNameNode = doc.CreateElement("name");
                        if (description.getNameSoundPath() != null && !description.getNameSoundPath().Equals(""))
                        {
                            aaNameNode.SetAttribute("soundPath", description.getNameSoundPath());
                        }
                        aaNameNode.AppendChild(doc.CreateTextNode(description.getName()));
                        descriptionNode.AppendChild(aaNameNode);

                        XmlElement aaBriefNode = doc.CreateElement("brief");
                        if (description.getDescriptionSoundPath() != null &&
                            !description.getDescriptionSoundPath().Equals(""))
                        {
                            aaBriefNode.SetAttribute("soundPath", description.getDescriptionSoundPath());
                        }
                        aaBriefNode.AppendChild(doc.CreateTextNode(description.getDescription()));
                        descriptionNode.AppendChild(aaBriefNode);

                        XmlElement aaDetailedNode = doc.CreateElement("detailed");
                        if (description.getDetailedDescriptionSoundPath() != null &&
                            !description.getDetailedDescriptionSoundPath().Equals(""))
                        {
                            aaDetailedNode.SetAttribute("soundPath", description.getDetailedDescriptionSoundPath());
                        }
                        aaDetailedNode.AppendChild(doc.CreateTextNode(description.getDetailedDescription()));
                        descriptionNode.AppendChild(aaDetailedNode);

                        // Append the description
                        aaElement.AppendChild(descriptionNode);
                    }

                    // Append the actions (if there is at least one)
                    if (activeArea.getActions().Count > 0)
                    {
                        DOMWriterUtility.DOMWrite(aaElement, activeArea.getActions());
                    }

                    if (!activeArea.isRectangular())
                    {
                        foreach (Vector2 point in activeArea.getPoints())
                        {
                            XmlElement pointNode = doc.CreateElement("point");
                            pointNode.SetAttribute("x", ((int)point.x).ToString());
                            pointNode.SetAttribute("y", ((int)point.y).ToString());
                            aaElement.AppendChild(pointNode);
                        }
                    }

                    // Append the exit
                    aasElement.AppendChild(aaElement);
                }
                // Append the list of exits
                sceneElement.AppendChild(aasElement);
            }

            // Append the barriers (if there is at least one)
            if (scene.getBarriers().Count > 0)
            {
                XmlNode barriersElement = doc.CreateElement("barriers");

                // Append every single barrier
                foreach (Barrier barrier in scene.getBarriers())
                {
                    // Create the active area element
                    XmlElement barrierElement = doc.CreateElement("barrier");
                    barrierElement.SetAttribute("x", barrier.getX().ToString());
                    barrierElement.SetAttribute("y", barrier.getY().ToString());
                    barrierElement.SetAttribute("width", barrier.getWidth().ToString());
                    barrierElement.SetAttribute("height", barrier.getHeight().ToString());

                    // Append the documentation (if avalaible)
                    if (barrier.getDocumentation() != null)
                    {
                        XmlNode exitDocumentationNode = doc.CreateElement("documentation");
                        exitDocumentationNode.AppendChild(doc.CreateTextNode(barrier.getDocumentation()));
                        barrierElement.AppendChild(exitDocumentationNode);
                    }

                    // Append the conditions (if avalaible)
                    if (!barrier.getConditions().IsEmpty())
                    {
                        DOMWriterUtility.DOMWrite(barrierElement, barrier.getConditions());
                    }

                    // Append the barrier
                    barriersElement.AppendChild(barrierElement);
                }
                // Append the list of exits
                sceneElement.AppendChild(barriersElement);
            }

            // Add the atrezzo item references (if there is at least one)
            if (scene.getAtrezzoReferences().Count > 0)
            {
                XmlNode atrezzoNode = doc.CreateElement("atrezzo");

                // Append every single atrezzo reference
                foreach (ElementReference atrezzoReference in scene.getAtrezzoReferences())
                {
                    // Create the atrezzo reference element
                    XmlElement atrezzoReferenceElement = doc.CreateElement("atrezzo-ref");
                    atrezzoReferenceElement.SetAttribute("idTarget", atrezzoReference.getTargetId());
                    atrezzoReferenceElement.SetAttribute("x", atrezzoReference.getX().ToString());
                    atrezzoReferenceElement.SetAttribute("y", atrezzoReference.getY().ToString());
                    atrezzoReferenceElement.SetAttribute("scale", atrezzoReference.Scale.ToString(CultureInfo.InvariantCulture));
                    if (atrezzoReference.getLayer() != -1)
                    {
                        atrezzoReferenceElement.SetAttribute("layer", atrezzoReference.getLayer().ToString());
                    }

                    // Append the documentation (if avalaible)
                    if (atrezzoReference.getDocumentation() != null)
                    {
                        XmlNode itemDocumentationNode = doc.CreateElement("documentation");
                        itemDocumentationNode.AppendChild(doc.CreateTextNode(atrezzoReference.getDocumentation()));
                        atrezzoReferenceElement.AppendChild(itemDocumentationNode);
                    }

                    // Append the conditions (if avalaible)
                    if (!atrezzoReference.Conditions.IsEmpty())
                    {
                        DOMWriterUtility.DOMWrite(atrezzoReferenceElement, atrezzoReference.Conditions);
                    }

                    // Append the atrezzo reference
                    atrezzoNode.AppendChild(atrezzoReferenceElement);
                }
                // Append the list of atrezzo references
                sceneElement.AppendChild(atrezzoNode);
            }

            if (scene.getTrajectory() != null)
            {
                DOMWriterUtility.DOMWrite(sceneElement, scene.getTrajectory());
            }
        }
        public static bool writeAnimation(string filename, Animation animation)
        {
            bool            dataSaved      = false;
            XmlDocument     doc            = doc = new XmlDocument();
            XmlDeclaration  declaration    = doc.CreateXmlDeclaration("1.0", "UTF-8", "no");
            XmlDocumentType typeDescriptor = doc.CreateDocumentType("animation", "SYSTEM", "animation.dtd", null);

            doc.AppendChild(declaration);
            doc.AppendChild(typeDescriptor);
            XmlElement mainNode = doc.CreateElement("animation");

            //mainNode.AppendChild(doc.createAttribute("id").setNodeValue(animation.getId()));
            mainNode.SetAttribute("id", animation.getId());
            mainNode.SetAttribute("usetransitions", animation.isUseTransitions() ? "yes" : "no");
            mainNode.SetAttribute("slides", animation.isSlides() ? "yes" : "no");
            XmlElement documentation = doc.CreateElement("documentation");

            if (animation.getDocumentation() != null && animation.getDocumentation().Length > 0)
            {
                documentation.InnerText = animation.getDocumentation();
            }
            mainNode.AppendChild(documentation);

            foreach (ResourcesUni resources in animation.getResources())
            {
                XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_ANIMATION);
                doc.ImportNode(resourcesNode, true);
                mainNode.AppendChild(resourcesNode);
            }

            for (int i = 0; i < animation.getFrames().Count; i++)
            {
                mainNode.AppendChild(createTransitionElement(animation.getTransitions()[i], doc));
                mainNode.AppendChild(createFrameElement(animation.getFrames()[i], doc));
            }
            mainNode.AppendChild(createTransitionElement(animation.getEndTransition(), doc));

            doc.ImportNode(mainNode, true);
            doc.AppendChild(mainNode);
            string name = "Assets/Resources/CurrentGame/" + filename;

            if (!name.EndsWith(".eaa"))
            {
                name += ".eaa";
            }
            doc.Save(name);
            System.IO.File.Copy(name, name.Substring(0, name.LastIndexOf(".")) + ".xml", true);
            //TODO: implementation?
            //transformer = tf.newTransformer();
            //transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, "animation.dtd");

            //try
            //{
            //    fout = new FileOutputStream(filename);
            //}
            //catch (FileNotFoundException e)
            //{
            //    fout = new FileOutputStream(Controller.getInstance().getProjectFolder() + "/" + filename);
            //}

            //writeFile = new OutputStreamWriter(fout, "UTF-8");
            //transformer.transform(new DOMSource(doc), new StreamResult(writeFile));
            //writeFile.close();
            //fout.close();

            dataSaved = true;

            return(dataSaved);
        }
Example #4
0
        protected override void FillNode(XmlNode node, object target, params IDOMWriterParam[] options)
        {
            var player = target as Player;

            XmlNode playerNode = node;

            // Create the necessary elements to create the DOM
            XmlDocument doc = Writer.GetDoc();


            // Append the documentation (if avalaible)
            if (player.getDocumentation() != null)
            {
                XmlNode playerDocumentationNode = doc.CreateElement("documentation");
                playerDocumentationNode.AppendChild(doc.CreateTextNode(player.getDocumentation()));
                playerNode.AppendChild(playerDocumentationNode);
            }

            // Append the resources
            foreach (ResourcesUni resources in player.getResources())
            {
                XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_CHARACTER);
                doc.ImportNode(resourcesNode, true);
                playerNode.AppendChild(resourcesNode);
            }

            // Create the textcolor
            XmlElement textColorNode = doc.CreateElement("textcolor");

            textColorNode.SetAttribute("showsSpeechBubble", (player.getShowsSpeechBubbles() ? "yes" : "no"));
            textColorNode.SetAttribute("bubbleBkgColor", ColorConverter.ColorToHex(player.getBubbleBkgColor()));
            textColorNode.SetAttribute("bubbleBorderColor", ColorConverter.ColorToHex(player.getBubbleBorderColor()));

            // Create and append the frontcolor
            XmlElement frontColorElement = doc.CreateElement("frontcolor");

            frontColorElement.SetAttribute("color", ColorConverter.ColorToHex(player.getTextFrontColor()));
            textColorNode.AppendChild(frontColorElement);

            // Create and append the bordercolor
            XmlElement borderColoElement = doc.CreateElement("bordercolor");

            borderColoElement.SetAttribute("color", ColorConverter.ColorToHex(player.getTextBorderColor()));
            textColorNode.AppendChild(borderColoElement);

            // Append the textcolor
            playerNode.AppendChild(textColorNode);

            foreach (Description description in player.getDescriptions())
            {
                // Create the description
                XmlNode descriptionNode = doc.CreateElement("description");

                // Append the conditions (if available)
                if (description.getConditions() != null && !description.getConditions().IsEmpty())
                {
                    DOMWriterUtility.DOMWrite(descriptionNode, description.getConditions());
                }

                // Create and append the name, brief description and detailed description
                XmlElement nameNode = doc.CreateElement("name");
                if (description.getNameSoundPath() != null && !description.getNameSoundPath().Equals(""))
                {
                    nameNode.SetAttribute("soundPath", description.getNameSoundPath());
                }
                nameNode.AppendChild(doc.CreateTextNode(description.getName()));
                descriptionNode.AppendChild(nameNode);

                XmlElement briefNode = doc.CreateElement("brief");
                if (description.getDescriptionSoundPath() != null && !description.getDescriptionSoundPath().Equals(""))
                {
                    briefNode.SetAttribute("soundPath", description.getDescriptionSoundPath());
                }
                briefNode.AppendChild(doc.CreateTextNode(description.getDescription()));
                descriptionNode.AppendChild(briefNode);

                XmlElement detailedNode = doc.CreateElement("detailed");
                if (description.getDetailedDescriptionSoundPath() != null &&
                    !description.getDetailedDescriptionSoundPath().Equals(""))
                {
                    detailedNode.SetAttribute("soundPath", description.getDetailedDescriptionSoundPath());
                }
                detailedNode.AppendChild(doc.CreateTextNode(description.getDetailedDescription()));
                descriptionNode.AppendChild(detailedNode);

                // Append the description
                playerNode.AppendChild(descriptionNode);
            }

            // Create the voice tag
            XmlElement voiceNode = doc.CreateElement("voice");

            // Create and append the voice name and if is alwaysSynthesizer
            voiceNode.SetAttribute("name", player.getVoice());
            if (player.isAlwaysSynthesizer())
            {
                voiceNode.SetAttribute("synthesizeAlways", "yes");
            }
            else
            {
                voiceNode.SetAttribute("synthesizeAlways", "no");
            }

            // Append the voice tag

            playerNode.AppendChild(voiceNode);
        }
        public static bool WriteAnimation(string filename, Animation animation)
        {
            bool        dataSaved = false;
            XmlDocument doc       = new XmlDocument();

            // Declaration, encoding, version, etc
            XmlDeclaration declaration = doc.CreateXmlDeclaration("1.0", "UTF-8", "no");

            doc.AppendChild(declaration);

            // DTD
            XmlDocumentType typeDescriptor = doc.CreateDocumentType("animation", "SYSTEM", "animation.dtd", null);

            doc.AppendChild(typeDescriptor);

            // Main animation node
            XmlElement mainNode = doc.CreateElement("animation");

            mainNode.SetAttribute("id", animation.getId());
            mainNode.SetAttribute("usetransitions", animation.isUseTransitions() ? "yes" : "no");
            mainNode.SetAttribute("slides", animation.isSlides() ? "yes" : "no");

            // Documentation node
            XmlElement documentation = doc.CreateElement("documentation");

            if (animation.getDocumentation() != null && animation.getDocumentation().Length > 0)
            {
                documentation.InnerText = animation.getDocumentation();
            }

            mainNode.AppendChild(documentation);

            // Resources in this animation
            foreach (ResourcesUni resources in animation.getResources())
            {
                // TODO update to domwriter resource
                XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_ANIMATION);
                doc.ImportNode(resourcesNode, true);
                mainNode.AppendChild(resourcesNode);
            }

            // Frames and transitions
            // TODO update to DOMWriter
            for (int i = 0; i < animation.getFrames().Count; i++)
            {
                mainNode.AppendChild(createTransitionElement(animation.getTransitions()[i], doc));
                mainNode.AppendChild(createFrameElement(animation.getFrames()[i], doc));
            }
            mainNode.AppendChild(createTransitionElement(animation.getEndTransition(), doc));
            doc.ImportNode(mainNode, true);
            doc.AppendChild(mainNode);

            // File saving
            string name = "Assets/uAdventure/Resources/CurrentGame/" + filename;

            if (!name.EndsWith(".eaa.xml"))
            {
                name += ".eaa.xml";
            }

            try
            {
                // Save
                doc.Save(name);
                dataSaved = true;
            }
            catch (System.Exception ex)
            {
                Debug.Log("Couldn't save Animation file \"" + name + "\": " + ex.Message);
            }

            return(dataSaved);
        }
Example #6
0
        protected override void FillNode(XmlNode node, object target, params IDOMWriterParam[] options)
        {
            var        atrezzo        = target as Atrezzo;
            XmlElement atrezzoElement = node as XmlElement;

            // Create the necessary elements to create the DOM
            XmlDocument doc = Writer.GetDoc();

            // Create the root node
            atrezzoElement.SetAttribute("id", atrezzo.getId());

            // Append the documentation (if avalaible)
            if (atrezzo.getDocumentation() != null)
            {
                XmlNode atrezzoDocumentationNode = doc.CreateElement("documentation");
                atrezzoDocumentationNode.AppendChild(doc.CreateTextNode(atrezzo.getDocumentation()));
                atrezzoElement.AppendChild(atrezzoDocumentationNode);
            }

            // Append the resources
            foreach (ResourcesUni resources in atrezzo.getResources())
            {
                XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_ITEM);
                doc.ImportNode(resourcesNode, true);
                atrezzoElement.AppendChild(resourcesNode);
            }

            // atrezzo only have name
            // Create the description
            XmlNode descriptionNode = doc.CreateElement("description");

            // Create and append the name, brief description and detailed description and its soundPaths
            XmlElement nameNode = doc.CreateElement("name");

            if (atrezzo.getDescription(0).getNameSoundPath() != null &&
                !atrezzo.getDescription(0).getNameSoundPath().Equals(""))
            {
                nameNode.SetAttribute("soundPath", atrezzo.getDescription(0).getNameSoundPath());
            }
            nameNode.AppendChild(doc.CreateTextNode(atrezzo.getDescription(0).getName()));
            descriptionNode.AppendChild(nameNode);

            XmlElement briefNode = doc.CreateElement("brief");

            /* if (description.getDescriptionSoundPath( )!=null && !description.getDescriptionSoundPath( ).Equals( "" )){
             *       briefNode.SetAttribute( "soundPath", description.getDescriptionSoundPath( ) );
             *   }
             *   briefNode.AppendChild( doc.CreateTextNode( description.getDescription( ) ) );*/
            briefNode.AppendChild(doc.CreateTextNode(""));
            descriptionNode.AppendChild(briefNode);

            XmlElement detailedNode = doc.CreateElement("detailed");

            /* if (description.getDetailedDescriptionSoundPath( )!=null && !description.getDetailedDescriptionSoundPath( ).Equals( "" )){
             *       detailedNode.SetAttribute( "soundPath", description.getDetailedDescriptionSoundPath( ) );
             *   }
             *   detailedNode.AppendChild( doc.CreateTextNode( description.getDetailedDescription( ) ) );*/
            detailedNode.AppendChild(doc.CreateTextNode(""));
            descriptionNode.AppendChild(detailedNode);

            // Append the description
            atrezzoElement.AppendChild(descriptionNode);
        }
Example #7
0
        /**
         * Recursive function responsible for transforming a node (and its children)
         * into a DOM structure
         *
         * @param currentNode
         *            Node to be transformed
         * @param rootDOMNode
         *            DOM node in which the elements must be attached
         */

        private static void WriteNodeInDom(ConversationNode currentNode, XmlNode rootDOMNode, params IDOMWriterParam[] options)
        {
            // Extract the document
            XmlDocument document = rootDOMNode.OwnerDocument;

            // If the node is a DialogueNode write the lines one after another, and then the child (or the mark if it is no
            // child)
            if (currentNode is DialogueConversationNode)
            {
                // For each line of the node
                for (int i = 0; i < currentNode.getLineCount(); i++)
                {
                    // Create a phrase element, and extract the actual text line
                    XmlElement       phrase;
                    ConversationLine line = currentNode.getLine(i);

                    // If the line belongs to the player, create a "speak-player" element. Otherwise, if it belongs to a
                    // NPC,
                    // create a "speak-char" element, which will have an attribute "idTarget" with the name of the
                    // non-playable character,
                    // if there is no name the attribute won't be written
                    if (line.isPlayerLine())
                    {
                        phrase = document.CreateElement("speak-player");
                    }
                    else
                    {
                        phrase = document.CreateElement("speak-char");
                        if (!line.getName().Equals("NPC"))
                        {
                            phrase.SetAttribute("idTarget", line.getName());
                        }
                    }

                    // Add the line text into the element
                    var text = document.CreateElement("text");
                    text.InnerText = line.getText();
                    phrase.AppendChild(text);

                    // Append the resources
                    foreach (ResourcesUni resources in line.getResources())
                    {
                        XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_CONVERSATION_LINE);
                        document.ImportNode(resourcesNode, true);
                        phrase.AppendChild(resourcesNode);
                    }

                    // Add the element to the DOM root
                    rootDOMNode.AppendChild(phrase);

                    // Create conditions for current effect
                    DOMWriterUtility.DOMWrite(rootDOMNode, line.getConditions(), options);
                }

                // Check if the node is terminal
                if (currentNode.isTerminal())
                {
                    // If it is terminal add a "end-conversation" element
                    XmlElement endConversation = document.CreateElement("end-conversation");

                    // Add the "end-conversation" tag into the root
                    rootDOMNode.AppendChild(endConversation);

                    // If the terminal node has an effect, include it into the DOM
                    if (currentNode.hasEffects())
                    {
                        DOMWriterUtility.DOMWrite(endConversation, currentNode.getEffects(), options);
                    }
                }
                else
                {
                    // If the node isn't terminal, check if it performing a "go-back" (going back to the inmediatly upper
                    // OptionNode)
                    if (TreeConversation.thereIsGoBackTag(currentNode))
                    {
                        // If it is the case, add a "go-back" element
                        rootDOMNode.AppendChild(document.CreateElement("go-back"));
                    }
                    else
                    {
                        // Otherwise, if the node has a child, call the recursive function with the child node, and the same
                        // DOM root node
                        WriteNodeInDom(currentNode.getChild(0), rootDOMNode);
                    }
                }
            }

            // If the node is a OptionNode write a "response" element, and inside it a "option" element with its content
            else if (currentNode is OptionConversationNode)
            {
                // Create the "response" element
                XmlElement response = document.CreateElement("response");
                // Adds a random attribute if "random" is activate in conversation node data
                if (((OptionConversationNode)currentNode).isRandom())
                {
                    response.SetAttribute("random", "yes");
                }
                // For each line of the node (we suppose the number of line equals the number of links, or children nodes)
                for (int i = 0; i < currentNode.getLineCount(); i++)
                {
                    // Create the "option" element
                    XmlElement       optionElement = document.CreateElement("option");
                    ConversationLine line          = currentNode.getLine(i);
                    // Create the actual option (a "speak-player" element) and add its respective text
                    XmlElement lineElement = document.CreateElement("speak-player");

                    var text = document.CreateElement("text");
                    text.InnerText = currentNode.getLine(i).getText();
                    lineElement.AppendChild(text);

                    // Append the resources
                    foreach (ResourcesUni resources in line.getResources())
                    {
                        XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_CONVERSATION_LINE);
                        document.ImportNode(resourcesNode, true);
                        lineElement.AppendChild(resourcesNode);
                    }

                    // Insert the text line in the option node
                    optionElement.AppendChild(lineElement);

                    // Call the recursive function, to write in the "option" node the appropiate elements
                    // Note that the root DOM node is the "option" element
                    WriteNodeInDom(currentNode.getChild(i), optionElement);

                    // Add the "option" element
                    response.AppendChild(optionElement);
                }
                // If the terminal node has an effect, include it into the DOM
                if (currentNode.hasEffects())
                {
                    DOMWriterUtility.DOMWrite(response, currentNode.getEffects(), options);
                }

                // Add the element
                rootDOMNode.AppendChild(response);
            }
        }
Example #8
0
        private void FillNode(XmlNode toFill, GraphConversation graphConversation, params IDOMWriterParam[] options)
        {
            XmlElement conversationElement = toFill as XmlElement;

            // Get the complete node list
            List <ConversationNode> nodes = graphConversation.getAllNodes();

            // Create the necessary elements to create the DOM
            XmlDocument doc = Writer.GetDoc();

            // Create the root node
            conversationElement.SetAttribute("id", graphConversation.getId());

            // For each node
            for (int i = 0; i < nodes.Count; i++)
            {
                ConversationNode node = nodes[i];

                XmlElement nodeElement            = null;
                var        dialogConversationNode = node as DialogueConversationNode;

                // If the node is a dialogue node
                if (dialogConversationNode != null)
                {
                    // Create the node element and set the nodeindex
                    nodeElement = doc.CreateElement("dialogue-node");
                    nodeElement.SetAttribute("nodeindex", i.ToString());
                    // Adds a random attribute if "keepShowing" is activate in conversation node data
                    if (dialogConversationNode.isKeepShowing())
                    {
                        nodeElement.SetAttribute("keepShowing", "yes");
                    }
                    if (node.getEditorX() != -1)
                    {
                        nodeElement.SetAttribute("editor-x", node.getEditorX().ToString());
                    }
                    if (node.getEditorY() != -1)
                    {
                        nodeElement.SetAttribute("editor-y", node.getEditorY().ToString());
                    }
                    if (node.getEditorCollapsed())
                    {
                        nodeElement.SetAttribute("editor-collapsed", "yes");
                    }
                    // For each line of the node
                    for (int j = 0; j < node.getLineCount(); j++)
                    {
                        // Create a phrase element, and extract the actual text line
                        XmlElement       phrase;
                        ConversationLine line = node.getLine(j);

                        // If the line belongs to the player, create a "speak-player" element. Otherwise, if it belongs
                        // to a NPC,
                        // create a "speak-char" element, which will have an attribute "idTarget" with the name of the
                        // non-playable character,
                        // if there is no name the attribute won't be written
                        if (line.isPlayerLine())
                        {
                            phrase = doc.CreateElement("speak-player");
                        }
                        else
                        {
                            phrase = doc.CreateElement("speak-char");
                            if (!line.getName().Equals("NPC"))
                            {
                                phrase.SetAttribute("idTarget", line.getName());
                            }
                        }

                        // Append the resources
                        foreach (ResourcesUni resources in line.getResources())
                        {
                            XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_CONVERSATION_LINE);
                            doc.ImportNode(resourcesNode, true);
                            phrase.AppendChild(resourcesNode);
                        }

                        // Add the line text into the element

                        var text = doc.CreateElement("text");
                        text.InnerText = line.getText();
                        phrase.AppendChild(text);

                        // Add the element to the node
                        nodeElement.AppendChild(phrase);

                        // Create conditions for current effect
                        DOMWriterUtility.DOMWrite(nodeElement, line.getConditions(), options);
                    }

                    // Check if the node is terminal
                    if (node.isTerminal())
                    {
                        // If it is terminal add a "end-conversation" element
                        XmlElement endConversation = doc.CreateElement("end-conversation");

                        // If the terminal node has an effect, include it into the DOM
                        if (node.hasEffects())
                        {
                            DOMWriterUtility.DOMWrite(endConversation, node.getEffects(), options);
                        }

                        // Add the "end-conversation" tag into the node
                        nodeElement.AppendChild(endConversation);
                    }
                    else
                    {
                        // Otherwise, if the node has a child, add the element
                        XmlElement childElement = doc.CreateElement("child");

                        // Add the number of the child node (index of the node in the structure)
                        childElement.SetAttribute("nodeindex", nodes.IndexOf(node.getChild(0)).ToString());

                        // Insert the tag into the node
                        nodeElement.AppendChild(childElement);

                        // If the terminal node has an effect, include it into the DOM
                        if (node.hasEffects())
                        {
                            DOMWriterUtility.DOMWrite(nodeElement, node.getEffects(), options);
                        }
                    }
                }

                var optionConversationNode = node as OptionConversationNode;
                // If the node is a option node
                if (optionConversationNode != null)
                {
                    // Create the node element and set the nodeindex
                    nodeElement = doc.CreateElement("option-node");
                    nodeElement.SetAttribute("nodeindex", i.ToString());

                    if (!string.IsNullOrEmpty(optionConversationNode.getXApiQuestion()))
                    {
                        nodeElement.SetAttribute("question", optionConversationNode.getXApiQuestion());
                    }

                    // Adds a random attribute if "random" is activate in conversation node data
                    if (optionConversationNode.isRandom())
                    {
                        nodeElement.SetAttribute("random", "yes");
                    }
                    // Adds a random attribute if "keepShowing" is activate in conversation node data
                    if (optionConversationNode.isKeepShowing())
                    {
                        nodeElement.SetAttribute("keepShowing", "yes");
                    }
                    // Adds a random attribute if "showUserOption" is activate in conversation node data
                    if (optionConversationNode.isShowUserOption())
                    {
                        nodeElement.SetAttribute("showUserOption", "yes");
                    }
                    // Adds a random attribute if "preListening" is activate in conversation node data
                    if (optionConversationNode.isPreListening())
                    {
                        nodeElement.SetAttribute("preListening", "yes");
                    }
                    if (node.getEditorX() != -1)
                    {
                        nodeElement.SetAttribute("editor-x", node.getEditorX().ToString());
                    }
                    if (node.getEditorY() != -1)
                    {
                        nodeElement.SetAttribute("editor-y", node.getEditorY().ToString());
                    }
                    if (node.getEditorCollapsed())
                    {
                        nodeElement.SetAttribute("editor-collapsed", "yes");
                    }
                    // Adds the x position of the options conversations node
                    nodeElement.SetAttribute("x", optionConversationNode.getEditorX().ToString());
                    // Adds a random attribute if "preListening" is activate in conversation node data
                    nodeElement.SetAttribute("y", optionConversationNode.getEditorY().ToString());

                    // For each line of the node
                    for (int j = 0; j < node.getLineCount(); j++)
                    {
                        // Take the current conversation line
                        ConversationLine line = node.getLine(j);

                        // Create the actual option (a "speak-player" element) and add its respective text
                        XmlElement lineElement = doc.CreateElement("speak-player");

                        var text = doc.CreateElement("text");
                        text.InnerText = node.getLine(j).getText();
                        lineElement.AppendChild(text);

                        // Append the resources
                        foreach (ResourcesUni resources in line.getResources())
                        {
                            XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_CONVERSATION_LINE);
                            doc.ImportNode(resourcesNode, true);
                            lineElement.AppendChild(resourcesNode);
                        }

                        if (line.getXApiCorrect())
                        {
                            lineElement.SetAttribute("correct", line.getXApiCorrect().ToString().ToLower());
                        }

                        // Create a child tag, and set it the index of the child
                        XmlElement childElement = doc.CreateElement("child");
                        childElement.SetAttribute("nodeindex", nodes.IndexOf(node.getChild(j)).ToString());


                        // Insert the text line in the option node
                        nodeElement.AppendChild(lineElement);
                        // Add conditions associated to that effect
                        DOMWriterUtility.DOMWrite(nodeElement, line.getConditions(), options);
                        // Insert child tag
                        nodeElement.AppendChild(childElement);
                    }

                    if (optionConversationNode.Timeout >= 0)
                    {
                        // Timeout
                        XmlElement timeoutElement = doc.CreateElement("timeout");
                        timeoutElement.InnerText = optionConversationNode.Timeout.ToString();
                        nodeElement.AppendChild(timeoutElement);
                        // Timeout conditions
                        DOMWriterUtility.DOMWrite(nodeElement, optionConversationNode.TimeoutConditions);

                        // Create a child tag, and set it the index of the child
                        XmlElement timeoutchildElement = doc.CreateElement("child");
                        timeoutchildElement.SetAttribute("nodeindex", nodes.IndexOf(node.getChild(node.getChildCount() - 1)).ToString());
                        nodeElement.AppendChild(timeoutchildElement);
                    }

                    // If node has an effect, include it into the DOM
                    if (node.hasEffects())
                    {
                        DOMWriterUtility.DOMWrite(nodeElement, node.getEffects(), options);
                    }
                }

                // Add the node to the conversation
                conversationElement.AppendChild(nodeElement);
            }
        }
        /**
         * Build a node from a list of actions
         *
         * @param actions
         *            the list of actions
         * @return the xml node with the list of actions
         */

        public void BuildDOM(XmlNode parent, object target, params IDOMWriterParam[] options)
        {
            var        actions        = target as List <Action>;
            XmlElement actionsElement = null;


            XmlDocument doc = Writer.GetDoc();

            // Create the root node
            actionsElement = doc.CreateElement("actions");

            // Append the actions (if there is at least one)
            if (actions.Count > 0)
            {
                // For every action
                foreach (Action action in actions)
                {
                    XmlElement actionElement = null;

                    // Create the element
                    switch (action.getType())
                    {
                    case Action.EXAMINE:
                        actionElement = doc.CreateElement("examine");
                        break;

                    case Action.GRAB:
                        actionElement = doc.CreateElement("grab");
                        break;

                    case Action.USE:
                        actionElement = doc.CreateElement("use");
                        break;

                    case Action.TALK_TO:
                        actionElement = doc.CreateElement("talk-to");
                        break;

                    case Action.USE_WITH:
                        actionElement = doc.CreateElement("use-with");
                        actionElement.SetAttribute("idTarget", action.getTargetId());
                        break;

                    case Action.GIVE_TO:
                        actionElement = doc.CreateElement("give-to");
                        actionElement.SetAttribute("idTarget", action.getTargetId());
                        break;

                    case Action.DRAG_TO:
                        actionElement = doc.CreateElement("drag-to");
                        actionElement.SetAttribute("idTarget", action.getTargetId());
                        break;

                    case Action.CUSTOM:
                        actionElement = doc.CreateElement("custom");
                        actionElement.SetAttribute("name", ((CustomAction)action).getName());
                        foreach (ResourcesUni resources in ((CustomAction)action).getResources())
                        {
                            XmlNode resourcesXmlNode = ResourcesDOMWriter.buildDOM(resources,
                                                                                   ResourcesDOMWriter.RESOURCES_CUSTOM_ACTION);
                            //doc.adoptXmlNode(resourcesXmlNode);
                            doc.ImportNode(resourcesXmlNode, true);
                            actionElement.AppendChild(resourcesXmlNode);
                        }
                        break;

                    case Action.CUSTOM_INTERACT:
                        actionElement = doc.CreateElement("custom-interact");
                        actionElement.SetAttribute("idTarget", action.getTargetId());
                        actionElement.SetAttribute("name", ((CustomAction)action).getName());
                        foreach (ResourcesUni resources in ((CustomAction)action).getResources())
                        {
                            XmlNode resourcesXmlNode = ResourcesDOMWriter.buildDOM(resources,
                                                                                   ResourcesDOMWriter.RESOURCES_CUSTOM_ACTION);
                            doc.ImportNode(resourcesXmlNode, true);
                            actionElement.AppendChild(resourcesXmlNode);
                        }
                        break;
                    }

                    actionElement.SetAttribute("needsGoTo", (action.isNeedsGoTo() ? "yes" : "no"));
                    actionElement.SetAttribute("keepDistance", "" + action.getKeepDistance());
                    actionElement.SetAttribute("not-effects", action.isActivatedNotEffects() ? "yes" : "no");

                    // Append the documentation (if avalaible)
                    if (action.getDocumentation() != null)
                    {
                        XmlNode actionDocumentationXmlNode = doc.CreateElement("documentation");
                        actionDocumentationXmlNode.AppendChild(doc.CreateTextNode(action.getDocumentation()));
                        actionElement.AppendChild(actionDocumentationXmlNode);
                    }

                    // Append the conditions (if avalaible)
                    if (!action.getConditions().isEmpty())
                    {
                        DOMWriterUtility.DOMWrite(actionElement, action.getConditions());
                    }

                    // Append the effects (if avalaible)
                    if (!action.getEffects().isEmpty())
                    {
                        DOMWriterUtility.DOMWrite(actionElement, action.getEffects());
                    }
                    // Append the not effects (if avalaible)
                    if (action.getNotEffects() != null && !action.getNotEffects().isEmpty())
                    {
                        DOMWriterUtility.DOMWrite(actionElement, action.getNotEffects(), DOMWriterUtility.Name(EffectsDOMWriter.NOT_EFFECTS));
                    }

                    // Append the action element
                    actionsElement.AppendChild(actionElement);
                }
            }

            parent.AppendChild(actionsElement);
        }
        protected override void FillNode(XmlNode node, object target, params IDOMWriterParam[] options)
        {
            var character = target as NPC;

            XmlElement characterElement = node as XmlElement;

            // Create the necessary elements to create the DOM
            XmlDocument doc = Writer.GetDoc();

            // Add root node attributes
            characterElement.SetAttribute("id", character.getId());

            // Append the documentation (if avalaible)
            if (character.getDocumentation() != null)
            {
                XmlNode characterDocumentationNode = doc.CreateElement("documentation");
                characterDocumentationNode.AppendChild(doc.CreateTextNode(character.getDocumentation()));
                characterElement.AppendChild(characterDocumentationNode);
            }

            // Append the resources
            foreach (ResourcesUni resources in character.getResources())
            {
                XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_CHARACTER);
                doc.ImportNode(resourcesNode, true);
                characterElement.AppendChild(resourcesNode);
            }

            // Create the textcolor
            XmlElement textColorNode = doc.CreateElement("textcolor");

            textColorNode.SetAttribute("showsSpeechBubble", (character.getShowsSpeechBubbles() ? "yes" : "no"));
            textColorNode.SetAttribute("bubbleBkgColor", ColorConverter.ColorToHex(character.getBubbleBkgColor()));
            textColorNode.SetAttribute("bubbleBorderColor", ColorConverter.ColorToHex(character.getBubbleBorderColor()));

            // Create and append the frontcolor
            XmlElement frontColorElement = doc.CreateElement("frontcolor");

            frontColorElement.SetAttribute("color", ColorConverter.ColorToHex(character.getTextFrontColor()));
            textColorNode.AppendChild(frontColorElement);

            // Create and append the bordercolor
            XmlElement borderColoElement = doc.CreateElement("bordercolor");

            borderColoElement.SetAttribute("color", ColorConverter.ColorToHex(character.getTextBorderColor()));
            textColorNode.AppendChild(borderColoElement);

            // Append the textcolor
            characterElement.AppendChild(textColorNode);

            //v1.4
            if (character.getBehaviour() == Item.BehaviourType.NORMAL)
            {
                characterElement.SetAttribute("behaviour", "normal");
            }
            if (character.getBehaviour() == Item.BehaviourType.ATREZZO)
            {
                characterElement.SetAttribute("behaviour", "atrezzo");
            }
            if (character.getBehaviour() == Item.BehaviourType.FIRST_ACTION)
            {
                characterElement.SetAttribute("behaviour", "first-action");
            }
            //v1.4


            foreach (Description description in character.getDescriptions())
            {
                // Create the description
                XmlNode descriptionNode = doc.CreateElement("description");
                // Append the conditions (if available)
                if (description.getConditions() != null && !description.getConditions().IsEmpty())
                {
                    DOMWriterUtility.DOMWrite(descriptionNode, description.getConditions());
                }

                // Create and append the name, brief description and detailed description and its soundPaths
                XmlElement nameNode = doc.CreateElement("name");
                if (description.getNameSoundPath() != null && !description.getNameSoundPath().Equals(""))
                {
                    nameNode.SetAttribute("soundPath", description.getNameSoundPath());
                }
                nameNode.AppendChild(doc.CreateTextNode(description.getName()));
                descriptionNode.AppendChild(nameNode);

                XmlElement briefNode = doc.CreateElement("brief");
                if (description.getDescriptionSoundPath() != null && !description.getDescriptionSoundPath().Equals(""))
                {
                    briefNode.SetAttribute("soundPath", description.getDescriptionSoundPath());
                }
                briefNode.AppendChild(doc.CreateTextNode(description.getDescription()));
                descriptionNode.AppendChild(briefNode);

                XmlElement detailedNode = doc.CreateElement("detailed");
                if (description.getDetailedDescriptionSoundPath() != null &&
                    !description.getDetailedDescriptionSoundPath().Equals(""))
                {
                    detailedNode.SetAttribute("soundPath", description.getDetailedDescriptionSoundPath());
                }
                detailedNode.AppendChild(doc.CreateTextNode(description.getDetailedDescription()));
                descriptionNode.AppendChild(detailedNode);

                // Append the description
                characterElement.AppendChild(descriptionNode);
            }

            // Create the voice tag
            XmlElement voiceNode = doc.CreateElement("voice");

            // Create and append the voice name and if is alwaysSynthesizer
            voiceNode.SetAttribute("name", character.getVoice());
            if (character.isAlwaysSynthesizer())
            {
                voiceNode.SetAttribute("synthesizeAlways", "yes");
            }
            else
            {
                voiceNode.SetAttribute("synthesizeAlways", "no");
            }

            // Append the voice tag

            characterElement.AppendChild(voiceNode);
            if (character.getActionsCount() > 0)
            {
                DOMWriterUtility.DOMWrite(characterElement, character.getActions());
            }
        }
Example #11
0
        protected override void FillNode(XmlNode node, object target, params IDOMWriterParam[] options)
        {
            var item = target as Item;

            XmlElement itemElement = node as XmlElement;


            // Create the necessary elements to create the DOM
            XmlDocument doc = Writer.GetDoc();

            // Create the root node
            itemElement.SetAttribute("id", item.getId());
            itemElement.SetAttribute("returnsWhenDragged", (item.isReturnsWhenDragged() ? "yes" : "no"));

            //v1.4
            if (item.getBehaviour() == Item.BehaviourType.NORMAL)
            {
                itemElement.SetAttribute("behaviour", "normal");
            }
            if (item.getBehaviour() == Item.BehaviourType.ATREZZO)
            {
                itemElement.SetAttribute("behaviour", "atrezzo");
            }
            if (item.getBehaviour() == Item.BehaviourType.FIRST_ACTION)
            {
                itemElement.SetAttribute("behaviour", "first-action");
            }
            itemElement.SetAttribute("resources-transition-time", item.getResourcesTransitionTime().ToString());
            //v1.4

            // Append the documentation (if avalaible)
            if (item.getDocumentation() != null)
            {
                XmlNode itemDocumentationNode = doc.CreateElement("documentation");
                itemDocumentationNode.AppendChild(doc.CreateTextNode(item.getDocumentation()));
                itemElement.AppendChild(itemDocumentationNode);
            }

            // Append the resources
            foreach (ResourcesUni resources in item.getResources())
            {
                XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_ITEM);
                doc.ImportNode(resourcesNode, true);
                itemElement.AppendChild(resourcesNode);
            }

            foreach (Description description in item.getDescriptions())
            {
                // Create the description
                XmlNode descriptionNode = doc.CreateElement("description");

                // Append the conditions (if available)
                if (description.getConditions() != null && !description.getConditions().isEmpty())
                {
                    DOMWriterUtility.DOMWrite(descriptionNode, description.getConditions());
                }

                // Create and append the name, brief description and detailed description and its soundPaths
                XmlElement nameNode = doc.CreateElement("name");

                if (description.getNameSoundPath() != null && !description.getNameSoundPath().Equals(""))
                {
                    nameNode.SetAttribute("soundPath", description.getNameSoundPath());
                }
                nameNode.AppendChild(doc.CreateTextNode(description.getName()));
                descriptionNode.AppendChild(nameNode);

                XmlElement briefNode = doc.CreateElement("brief");
                if (description.getDescriptionSoundPath() != null && !description.getDescriptionSoundPath().Equals(""))
                {
                    briefNode.SetAttribute("soundPath", description.getDescriptionSoundPath());
                }
                briefNode.AppendChild(doc.CreateTextNode(description.getDescription()));
                descriptionNode.AppendChild(briefNode);

                XmlElement detailedNode = doc.CreateElement("detailed");
                if (description.getDetailedDescriptionSoundPath() != null &&
                    !description.getDetailedDescriptionSoundPath().Equals(""))
                {
                    detailedNode.SetAttribute("soundPath", description.getDetailedDescriptionSoundPath());
                }
                detailedNode.AppendChild(doc.CreateTextNode(description.getDetailedDescription()));
                descriptionNode.AppendChild(detailedNode);

                // Append the description
                itemElement.AppendChild(descriptionNode);
            }

            // Append the actions (if there is at least one)
            if (item.getActions().Count > 0)
            {
                // Create the actions node
                DOMWriterUtility.DOMWrite(itemElement, item.getActions());
            }
        }
        protected override void FillNode(XmlNode node, object target, params IDOMWriterParam[] options)
        {
            var        book        = target as Book;
            XmlElement bookElement = node as XmlElement;

            // Create the necessary elements to create the DOM
            XmlDocument doc = Writer.GetDoc();

            // Add attributes to root node
            bookElement.SetAttribute("id", book.getId());

            // Adding next page position
            if (book.getNextPageVector2() != null)
            {
                bookElement.SetAttribute("xNextPage", book.getNextPageVector2().x + "");
                bookElement.SetAttribute("yNextPage", book.getNextPageVector2().y + "");
            }

            // Adding previous page position
            if (book.getPreviousPageVector2() != null)
            {
                bookElement.SetAttribute("xPreviousPage", book.getPreviousPageVector2().x + "");
                bookElement.SetAttribute("yPreviousPage", book.getPreviousPageVector2().y + "");
            }

            // Append the documentation (if avalaible)
            if (book.getDocumentation() != null)
            {
                XmlNode bookDocumentationNode = doc.CreateElement("documentation");
                bookDocumentationNode.AppendChild(doc.CreateTextNode(book.getDocumentation()));
                bookElement.AppendChild(bookDocumentationNode);
            }

            // Append the resources
            foreach (ResourcesUni resources in book.getResources())
            {
                XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_BOOK);
                doc.ImportNode(resourcesNode, true);
                bookElement.AppendChild(resourcesNode);
            }

            // Create the text/pages element

            XmlElement textPagesElement = null;

            if (book.getType() == Book.TYPE_PARAGRAPHS)
            {
                textPagesElement = doc.CreateElement("text");

                // Create and append the paragraphs
                foreach (BookParagraph bookParagraph in book.getParagraphs())
                {
                    XmlNode paragraphNode = null;

                    // If it is a text paragraph
                    if (bookParagraph.getType() == BookParagraph.TEXT)
                    {
                        paragraphNode = doc.CreateTextNode(bookParagraph.getContent());
                    }

                    // If it is a text paragraph
                    if (bookParagraph.getType() == BookParagraph.TITLE)
                    {
                        paragraphNode = doc.CreateElement("title");
                        paragraphNode.AppendChild(doc.CreateTextNode(bookParagraph.getContent()));
                    }

                    // If it is a bullet paragraph
                    else if (bookParagraph.getType() == BookParagraph.BULLET)
                    {
                        paragraphNode = doc.CreateElement("bullet");
                        paragraphNode.AppendChild(doc.CreateTextNode(bookParagraph.getContent()));
                    }

                    // If it is an image paragraph
                    else if (bookParagraph.getType() == BookParagraph.IMAGE)
                    {
                        XmlElement imageParagraphElement = doc.CreateElement("img");
                        imageParagraphElement.SetAttribute("src", bookParagraph.getContent());
                        paragraphNode = imageParagraphElement;
                    }

                    // Append the created paragraph
                    textPagesElement.AppendChild(paragraphNode);
                }
            }
            else if (book.getType() == Book.TYPE_PAGES)
            {
                textPagesElement = doc.CreateElement("pages");
                foreach (BookPage page in book.getPageURLs())
                {
                    if (page.getUri().Length > 0)
                    {
                        // Create the node for the page
                        XmlElement pageElement = doc.CreateElement("page");

                        //Attributes: uri, type, margin, scrollable
                        pageElement.SetAttribute("scrollable", (page.getScrollable() ? "yes" : "no"));
                        pageElement.SetAttribute("margin", page.getMargin().ToString());
                        if (page.getMarginEnd() != 0)
                        {
                            pageElement.SetAttribute("marginEnd", page.getMarginEnd().ToString());
                        }
                        if (page.getMarginTop() != 0)
                        {
                            pageElement.SetAttribute("marginTop", page.getMarginTop().ToString());
                        }
                        if (page.getMarginBottom() != 0)
                        {
                            pageElement.SetAttribute("marginBottom", page.getMarginBottom().ToString());
                        }
                        pageElement.SetAttribute("uri", page.getUri());
                        switch (page.getType())
                        {
                        case BookPage.TYPE_RESOURCE:
                            pageElement.SetAttribute("type", "resource");
                            break;

                        case BookPage.TYPE_IMAGE:
                            pageElement.SetAttribute("type", "image");
                            break;

                        case BookPage.TYPE_URL:
                            pageElement.SetAttribute("type", "url");
                            break;

                        default:
                            pageElement.SetAttribute("type", "url");
                            break;
                        }

                        textPagesElement.AppendChild(pageElement);
                    }
                }
            }
            // Append the text element
            bookElement.AppendChild(textPagesElement);
        }
        protected override void FillNode(XmlNode node, object target, params IDOMWriterParam[] options)
        {
            var cutscene        = target as Cutscene;
            var cutsceneElement = node as XmlElement;

            // Create the necessary elements to create the DOM
            XmlDocument doc = Writer.GetDoc();

            // Create the root node
            if (cutscene.getType() == GeneralScene.GeneralSceneSceneType.VIDEOSCENE)
            {
                if (((Videoscene)cutscene).isCanSkip())
                {
                    cutsceneElement.SetAttribute("canSkip", "yes");
                }
                else
                {
                    cutsceneElement.SetAttribute("canSkip", "no");
                }
            }

            // Set the attributes
            cutsceneElement.SetAttribute("id", cutscene.getId());


            if (options.Any(o => o is CIP && (o as CIP).TargetId.Equals(cutscene.getId())))
            {
                cutsceneElement.SetAttribute("start", "yes");
            }
            else
            {
                cutsceneElement.SetAttribute("start", "no");
            }

            if (cutscene.getNext() == Cutscene.NEWSCENE)
            {
                cutsceneElement.SetAttribute("idTarget", cutscene.getTargetId());

                cutsceneElement.SetAttribute("destinyX", cutscene.getPositionX().ToString());
                cutsceneElement.SetAttribute("destinyY", cutscene.getPositionY().ToString());

                cutsceneElement.SetAttribute("transitionTime", cutscene.getTransitionTime().ToString());
                cutsceneElement.SetAttribute("transitionType", ((int)cutscene.getTransitionType()).ToString());
            }

            if (cutscene.getNext() == Cutscene.GOBACK)
            {
                cutsceneElement.SetAttribute("next", "go-back");
            }
            else if (cutscene.getNext() == Cutscene.ENDCHAPTER)
            {
                cutsceneElement.SetAttribute("next", "end-chapter");
            }
            else if (cutscene.getNext() == Cutscene.NEWSCENE)
            {
                cutsceneElement.SetAttribute("next", "new-scene");
            }

            cutsceneElement.SetAttribute("class", cutscene.getXApiClass());
            cutsceneElement.SetAttribute("type", cutscene.getXApiType());

            // Append the documentation (if avalaible)
            if (cutscene.getDocumentation() != null)
            {
                XmlNode cutsceneDocumentationNode = doc.CreateElement("documentation");
                cutsceneDocumentationNode.AppendChild(doc.CreateTextNode(cutscene.getDocumentation()));
                cutsceneElement.AppendChild(cutsceneDocumentationNode);
            }

            if (!cutscene.getEffects().isEmpty())
            {
                DOMWriterUtility.DOMWrite(cutsceneElement, cutscene.getEffects());
            }

            // Append the resources
            foreach (ResourcesUni resources in cutscene.getResources())
            {
                XmlNode resourcesNode = ResourcesDOMWriter.buildDOM(resources, ResourcesDOMWriter.RESOURCES_CUTSCENE);
                doc.ImportNode(resourcesNode, true);
                cutsceneElement.AppendChild(resourcesNode);
            }

            // Append the name
            XmlNode nameNode = doc.CreateElement("name");

            nameNode.AppendChild(doc.CreateTextNode(cutscene.getName()));
            cutsceneElement.AppendChild(nameNode);
        }