/**
     * Creates a new ConversationReference
     *
     * @param idTarget
     *            the id of the conversation that is referenced
     */
    public ConversationReference(string idTarget)
    {
        this.idTarget = idTarget;

        documentation = null;
        conditions = new Conditions();
    }

 private static int GetMaxHappiness(Stack<string> atTable, List<string> free, Conditions conditions)
 {
     if (free.Count == 1)
     {
         atTable.Push(free.Single());
         var table = new Table(atTable.ToList());
         var totalHappiness = table.CalcTotalHappiness(conditions);
         atTable.Pop();
         return totalHappiness;
     }
     var maxHappiness = 0;
     for (int i = 0; i < free.Count; i++)
     {
         atTable.Push(free[i]);
         free.RemoveAt(i);
         var happiness = GetMaxHappiness(atTable, free, conditions);
         if (happiness > maxHappiness)
         {
             maxHappiness = happiness;
         }
         var person = atTable.Pop();
         free.Insert(i, person);
     }
     return maxHappiness;
 }

 public QueryConditionNode(QField lvalue, Conditions conditions, QConst rvalue)
     : base()
 {
     _RValue = rvalue;
     _Condition = conditions;
     _LValue = lvalue;
 }

 public static double ApplyCondition(double quality, Conditions condition)
 {
     switch(condition)
     {
         case Conditions.Poor:
             {
                 return quality * 0.5;
             }
         case Conditions.Normal:
             {
                 return quality * 1;
             }
         case Conditions.Good:
             {
                 return quality * 1.5;
             }
         case Conditions.Excellent:
             {
                 return quality * 4;
             }
         default:
             {
                 return quality * 1;
             }
     }
 }

 public MissionCondition()
 {
     _condition = Conditions.None;
     _checkValue = 0;
     _name = GetName(_condition);
     //_mission = null;
 }

        public static Conditions GetCondition(Random rng, Conditions previousCondition)
        {
            if(previousCondition == Conditions.Excellent)
            {
                return Conditions.Poor;
            }

            if(previousCondition == Conditions.Good || previousCondition == Conditions.Poor)
            {
                return Conditions.Normal;
            }

            int seed = rng.Next(1, 101);

            if(seed > 75)
            {
                if(seed > 98)
                {
                    return Conditions.Excellent;
                }
                else
                {
                    return Conditions.Good;
                }
            }
            else
            {
                return Conditions.Normal;
            }
        }

 /**
  * Creates a new Resources.
  */
 public ResourcesUni()
 {
     assets = new Dictionary<string, string>();
     // add the hash map of asset AllElements with asset
     AllElementsWithAssets.addAsset(assets);
     conditions = new Conditions();
     name = "No name";
 }

        public Car(string name, string details, int price, string type, string maker, int year, Conditions p):base(name, details, price)
        {

            this.Type = type;
            this.Maker = maker;
            this.YearMade = year;
            this.state = p;

        }

 /**
  * Creates a new Exit
  *
  * @param x
  *            The horizontal coordinate of the upper left corner of the exit
  * @param y
  *            The vertical coordinate of the upper left corner of the exit
  * @param width
  *            The width of the exit
  * @param height
  *            The height of the exit
  */
 public Barrier(string id, int x, int y, int width, int height)
     : base(id)
 {
     this.x = x;
     this.y = y;
     this.width = width;
     this.height = height;
     conditions = new Conditions();
 }

 public ConditionsJson MapConditions2Json(Conditions json)
 {
     return new ConditionsJson()
     {
         Chop = json.Chop,
         Flatwater = json.Flatwater,
         Waves = json.Waves
     };
 }

 /**
  * Default constructor
  *
  * @param id
  *            Id of the rule
  * @param importance
  *            Importance of the rule
  */
 public TimedAssessmentRule(string id, int importance, bool repeatRule)
     : base(id, importance, repeatRule)
 {
     effects = new List<TimedAssessmentEffect>();
     this.endConditions = new Conditions();
     usesEndConditions = true;
     effectIndex = -1;
     elapsedTime = 0;
     isDone = false;
 }

 /**
  * Creates a new ElementReference
  *
  * @param idTarget
  *            the id of the element that is referenced
  * @param x
  *            the horizontal position of the element
  * @param y
  *            the vertical position of the element
  */
 public ElementReference(string idTarget, int x, int y)
 {
     this.idTarget = idTarget;
     this.x = x;
     this.y = y;
     this.scale = 1;
     this.layer = -1;
     documentation = null;
     conditions = new Conditions();
     influenceArea = new InfluenceArea();
 }

    /**
     * Creates a new NextScene
     *
     * @param nextSceneId
     *            the id of the next scene
     */
    public NextScene(string nextSceneId)
    {
        this.nextSceneId = nextSceneId;

        destinyX = int.MinValue;
        destinyY = int.MinValue;
        conditions = new Conditions();
        effects = new Effects();
        postEffects = new Effects();
        transitionType = NextSceneEnumTransitionType.NO_TRANSITION;
        transitionTime = 0;
    }

    public override void ParseElement(XmlElement element)
    {
        XmlNodeList
            names = element.SelectNodes("name"),
            briefs = element.SelectNodes("brief"),
            detaileds = element.SelectNodes("detailed"),
            conditions = element.SelectNodes("condition");

        string tmpArgVal;
        foreach (XmlElement el in names)
        {
            string soundPath = "";

            tmpArgVal = el.GetAttribute("soundPath");
            if (!string.IsNullOrEmpty(tmpArgVal))
            {
                soundPath = tmpArgVal;
            }
            description.setNameSoundPath(soundPath);
            description.setName(el.InnerText);
        }

        foreach (XmlElement el in briefs)
        {
            string soundPath = "";

            tmpArgVal = el.GetAttribute("soundPath");
            if (!string.IsNullOrEmpty(tmpArgVal))
            {
                soundPath = tmpArgVal;
            }
            description.setDescriptionSoundPath(soundPath);
            description.setDescription(el.InnerText);
        }
        foreach (XmlElement el in detaileds)
        {
            string soundPath = "";

            tmpArgVal = el.GetAttribute("soundPath");
            if (!string.IsNullOrEmpty(tmpArgVal))
            {
                soundPath = tmpArgVal;
            }
            description.setDetailedDescriptionSoundPath(soundPath);
            description.setDetailedDescription(el.InnerText);
        }
        foreach (XmlElement el in conditions)
        {
            currentConditions = new Conditions();
            new ConditionSubParser_(currentConditions, chapter).ParseElement(el);
            this.description.setConditions(currentConditions);
        }
    }

 /**
  * Creates a new Exit
  *
  * @param rectangular
  *
  * @param x
  *            The horizontal coordinate of the upper left corner of the exit
  * @param y
  *            The vertical coordinate of the upper left corner of the exit
  * @param width
  *            The width of the exit
  * @param height
  *            The height of the exit
  */
 public ActiveArea(string id, bool rectangular, int x, int y, int width, int height)
     : base(id)
 {
     this.rectangular = rectangular;
     this.x = x;
     this.y = y;
     this.width = width;
     this.height = height;
     Vector2s = new List<Vector2>();
     conditions = new Conditions();
     influenceArea = new InfluenceArea();
 }

 public int CalcTotalHappiness(Conditions conditions)
 {
     var totalHappiness = 0;
     for (int i = 0; i < People.Count; i++)
     {
         var subjectName = People[i];
         string objectNameLeft;
         string objectNameRight;
         GetNeighbors(i, out objectNameLeft, out objectNameRight);
         totalHappiness += conditions.GetBySubjectAndObjectNames(subjectName, objectNameLeft).HappinessUnits;
         totalHappiness += conditions.GetBySubjectAndObjectNames(subjectName, objectNameRight).HappinessUnits;
     }
     return totalHappiness;
 }

        public void CloseResults()
        {
            EnsureStateNotAlreadySet(Conditions.Disposed);

            // We allow some resilience for writers that stream individual results to
            // the log without explicit opening/closing the results object
            if ((_writeConditions & Conditions.ResultsInitialized) != Conditions.ResultsInitialized ||
                (_writeConditions & Conditions.ResultsClosed) == Conditions.ResultsClosed)
            {
                return;
            }

            _jsonWriter.WriteEndArray();
            _writeConditions |= Conditions.ResultsClosed;
        }

    public Timer(long time, Conditions init, Conditions end, Effects effect, Effects postEffect)
    {
        this.seconds = time;
        this.initCond = init;
        this.endCond = end;
        this.effect = effect;
        this.postEffect = postEffect;
        usesEndCondition = true;
        runsInLoop = true;
        multipleStarts = true;

        showTime = false;
        displayName = "timer";
        countDown = true;
        showWhenStopped = false;
    }

        public string ExecuteAction(ICraft craft, ICrafter crafter, List<IModifier> activeModifiers, Random rng, Conditions condition)
        {
            string result = String.Empty;

            //Success!
            wasSuccessful = true;

            result = ActionName + " used!  " + Math.Abs(DurabilityUsed) + " durability restored.";

            craft.IncrementStep();
            craft.UpdateDurability(DurabilityUsed);
            crafter.UpdateCP(CPCost);

            this.actionUsed = true;
            return result;
        }

    public override void ParseElement(XmlElement element)
    {
        XmlNodeList
            conditions = element.SelectNodes("condition");

        string tmpArgVal;

        int x = 0, y = 0, width = 0, height = 0;

        tmpArgVal = element.GetAttribute("x");
        if (!string.IsNullOrEmpty(tmpArgVal))
        {
            x = int.Parse(tmpArgVal);
        }
        tmpArgVal = element.GetAttribute("y");
        if (!string.IsNullOrEmpty(tmpArgVal))
        {
            y = int.Parse(tmpArgVal);
        }
        tmpArgVal = element.GetAttribute("width");
        if (!string.IsNullOrEmpty(tmpArgVal))
        {
            width = int.Parse(tmpArgVal);
        }
        tmpArgVal = element.GetAttribute("height");
        if (!string.IsNullOrEmpty(tmpArgVal))
        {
            height = int.Parse(tmpArgVal);
        }
        barrier = new Barrier(generateId(), x, y, width, height);

        if (element.SelectSingleNode("documentation") != null)
            barrier.setDocumentation(element.SelectSingleNode("documentation").InnerText);

        foreach (XmlElement ell in conditions)
        {
            currentConditions = new Conditions();
            new ConditionSubParser_(currentConditions, chapter).ParseElement(ell);
            this.barrier.setConditions(currentConditions);
        }

        scene.addBarrier(barrier);
    }