public override LuaTable GetLuaTable(Mission mission)
		{
            Dictionary<object, object> map = new Dictionary<object, object>
				{
					{"message", message},
                    {"fontSize", FontSize},
                    {"time", time},
				};
            if (!string.IsNullOrEmpty(imagePath) && File.Exists(ImagePath))
			{
				var image = new BitmapImage(new Uri(ImagePath));
				map.Add("image", Path.GetFileName(ImagePath));
				map.Add("imageWidth", image.PixelWidth);
                map.Add("imageHeight", image.PixelHeight);
			}
            else if (!string.IsNullOrWhiteSpace(imagePath))
            {
                map.Add("image", ImagePath);
                map.Add("imageFromArchive", true);
            }
            if (!string.IsNullOrEmpty(soundPath) && File.Exists(SoundPath))
            {
                map.Add("sound", Path.GetFileName(soundPath));
            }
            else if (!string.IsNullOrWhiteSpace(soundPath))
            {
                map.Add("sound", soundPath);
                map.Add("soundFromArchive", true);
            }

            return new LuaTable(map);
		}

	override protected void _setCompleted(Mission mission, bool up, bool notify) {
		AndroidJNI.PushLocalFrame(100);
		using(AndroidJavaClass jniMissionStorage = new AndroidJavaClass("com.soomla.levelup.data.MissionStorage")) {
			jniMissionStorage.CallStatic("setCompleted", mission.ID, up, notify);
		}
		AndroidJNI.PopLocalFrame(IntPtr.Zero);
	}

    public void Random_Destination()
    {
        // randomly choose a mission
        // current_mission = missions[Random.Range(0,missions.Length)];

        current_mission = new Mission();
        current_mission.start_portal = startPoint[Random.Range(0,startPoint.Count)];

        // the destination can not be the start point's location
        List<GData.LocationType> locs
            = new List<GData.LocationType>(GameObject.FindObjectOfType<PortalSystem>().
                                           Get_Protals()[current_mission.start_portal].locations);
        Debug.Log("Locs : " + locs.Count);
        current_mission.destination = endPoint[Random.Range(0,endPoint.Count)];
        while(locs.Contains(current_mission.destination))
        {
            current_mission.destination = endPoint[Random.Range(0,endPoint.Count)];
        }

        current_mission.comment = "Find a way to " + current_mission.destination.ToString();
        current_mission.comment = current_mission.comment.Replace("_", " ");

        // place the player
        PortalSystem sys = GameObject.FindObjectOfType<PortalSystem>();
        sys.Place_Player(current_mission.start_portal);
    }

 public static Mission getMission(String id)
 {
     Mission mission = null;
     String parameter = "id";
     String query = DB.SELECT
                  + "*"
                  + DB.FROM
                  + Net7.Tables.missions
                  + DB.WHERE
                  + ColumnData.GetName(Net7.Table_missions._mission_id)
                  + DB.EQUALS
                  + DB.QueryParameterCharacter
                  + parameter;
     DataTable dataTable = DB.Instance.executeQuery(query, new String[]{parameter}, new String[] {id});
     if (dataTable.Rows.Count == 1)
     {
         mission = new Mission();
         mission.setId(id);
         mission.setXml(ColumnData.GetString(dataTable.Rows[0], Net7.Table_missions._mission_XML));
         mission.setName(ColumnData.GetString(dataTable.Rows[0], Net7.Table_missions._mission_name));
         String type = ColumnData.GetString(dataTable.Rows[0], Net7.Table_missions._mission_type);
         CommonTools.MissionType missionType;
         CommonTools.Enumeration.TryParse<CommonTools.MissionType>(type, out missionType);
         mission.setType(missionType);
         mission.setKey(ColumnData.GetString(dataTable.Rows[0], Net7.Table_missions._mission_key));
     }
     return mission;
 }

        //private DatabaseModel.Database<Mission> ListOfMissions = new DatabaseModel.Database<Mission>("ToDoList.txt");
        // Instead the above we need to call the parent window
        public CreateTaskWindow(DateTime taskDate, Mission editMission = null)
        {
            InitializeComponent();

            this.taskDate = taskDate;
            this.editMission = editMission;
            // this.missionFileControler = new MissionFileControler();
            List<PriorityLevel> priorityLevels = new List<PriorityLevel>();

            priorityLevels.Add(PriorityLevel.Low);
            priorityLevels.Add(PriorityLevel.Medium);
            priorityLevels.Add(PriorityLevel.Urgent);

            this.ComboBoxPriority.ItemsSource = priorityLevels;

            // set default value
            if (this.editMission == null)
            {
                this.ComboBoxPriority.SelectedValue = priorityLevels[0];
            }
            else
            {
                this.Title = "Edit task";
                this.ComboBoxPriority.SelectedValue = this.editMission.Priority;
                this.TextBoxName.Text = this.editMission.Name;
                this.TextBoxDescription.Text = this.editMission.Description;
                this.addButton.Content = "Update";
            }
        }

 /// <summary>
 /// Creates the mission from a hashtable sent over the PhotonNetwork.
 /// </summary>
 /// <param name="missionData">The hashtable containing the mission data.</param>
 public void SetMissionFromHashtable(Hashtable missionData)
 {
     print("mission created from hashtable");
     Mission newMission = new Mission(missionData);
     activeMission = newMission;
     SetMissionTimer();
 }

        protected void Page_Load(object sender, EventArgs e)
        {
            if (_Request.Get("missionID") != null)
            {
                int missionID = _Request.Get<int>("missionID", Method.Get, 0);

                Mission mission = MissionBO.Instance.GetMission(missionID, true);

                if (mission.ParentID != null)
                    m_ParentMission = MissionBO.Instance.GetMission(mission.ParentID.Value);
            }
            else if(_Request.Get("type") == null)
            {
                m_ParentMission = MissionBO.Instance.GetMission(_Request.Get<int>("pid", 0));

                if (m_ParentMission == null)
                {
                    ShowError("任务组不存在");
                    return;
                }
            }

            if (_Request.IsClick("savemission"))
                SaveMission();
        }

        public async Task<IHttpActionResult> PutMission(int id, Mission mission)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (id != mission.Id)
            {
                return BadRequest();
            }

            db.Entry(mission).State = EntityState.Modified;

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!MissionExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return StatusCode(HttpStatusCode.NoContent);
        }

		public override LuaTable GetLuaTable(Mission mission)
		{
			if (string.IsNullOrEmpty(imagePath) || !File.Exists(ImagePath))
			{
				var map = new Dictionary<object, object>
					{
						{"message", message},
						{"width", Width},
                        {"height", Height},
						{"pause", Pause},
                        {"fontSize", FontSize},
					};
                if(!string.IsNullOrWhiteSpace(imagePath))
                {
                    map.Add("image", imagePath);
                    map.Add("imageFromArchive", true);
                }
				return new LuaTable(map);
			}
			else
			{
				var image = new BitmapImage(new Uri(ImagePath));
				var map = new Dictionary<object, object>
					{
						{"message", message},
						{"image", Path.GetFileName(ImagePath)},
						{"imageWidth", image.PixelWidth},
						{"imageHeight", image.PixelHeight},
						{"pause", Pause},
                        {"fontSize", FontSize},
					};
				return new LuaTable(map);
			}
		}

        public void DeleteMission(Mission mission)
        {
            string tempFile = "temp.txt";
            string serializedMissionForDeleting = mission.Serialize();
            FileStream fsRead = new FileStream(MissionFilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
            FileStream fsWrite = new FileStream(tempFile, FileMode.Create, FileAccess.ReadWrite);

            using (StreamReader reader = new StreamReader(fsRead))
            {
                using (StreamWriter writer = new StreamWriter(fsWrite))
                {
                    while (!reader.EndOfStream)
                    {
                        string line = reader.ReadLine();

                        if (!line.Equals(serializedMissionForDeleting))
                        {
                            writer.WriteLine(line);
                        }
                    }
                }
            }

            File.Delete(MissionFileControler.MissionFilePath);
            File.Move(tempFile, MissionFileControler.MissionFilePath);
        }

    public void LoadDataromServer(string json_data)
    {
        var Json = SimpleJSON.JSON.Parse(json_data);
        missions = new List<Mission>(Json["missions"].Count);
        for (int a = 0; a < Json["missions"].Count; a++)
        {
            Mission newMission = new Mission();
            newMission.id = int.Parse(Json["missions"][a]["id"]);
            newMission.islandId = int.Parse(Json["missions"][a]["islandId"]);

            newMission.qty = int.Parse(Json["missions"][a]["qty"]);

            switch (Json["missions"][a]["element"])
            {
                case "MADERA": newMission.element = Mission.elements.MADERA; break;
                case "PIEDRAS": newMission.element = Mission.elements.PIEDRAS; break;
                case "ARENA": newMission.element = Mission.elements.ARENA; break;
            }
            newMission.description = Json["missions"][a]["description"];
          //  newMission.description = GetDescription(newMission);

            missions.Add(newMission);
        }
        //foreach(Mission mission in missions)
        //{
        //    Debug.Log("M: " + mission.description);
        //}
    }

 private void btnNewMission_Click(object sender, EventArgs e)
 {
     var mission = new Mission() {Name = "NEW MISSION", PartyLevel = 1};
     MissionLoader.Add(mission);
     lstMissions.DataSource = null;
     lstMissions.DataSource = MissionLoader.Get();
 }

 public void generateMission()
 {
     if (currentMission != null)
         return;
     MissionNumber++;
     currentMission = new Mission(MissionNumber, previousMission);
     if (previousMission == Mission.MissionType.Boss || previousMission == Mission.MissionType.BaseAssault)
     {
         spawnPoints = new List<enemySpawnPoint>();
         enemySpawnPoint[] sp = FindObjectsOfType<enemySpawnPoint>();
         foreach (enemySpawnPoint s in sp)
         {
             spawnPoints.Add(s);
         }
     }
     previousMission = currentMission.type;
     Title.Display(currentMission.missionTitle);
     Type.Display(currentMission.missionType);
     Objective.Display(currentMission.missionObjective);
     Bonus.Display(currentMission.missionBonusObjective);
     Reward.Display(currentMission.Reward);
     bReward.Display(currentMission.bonusReward);
     Difficulty.Display(currentMission.missionDifficulty);
     clearRemainingEnemies();
     setUpMission();
 }

		public override LuaTable GetLuaTable(Mission mission)
		{
			var map = new Dictionary<object, object>
				{
					{"noContinue", noContinue},
				};
			return new LuaTable(map);
		}

		public override LuaTable GetLuaTable(Mission mission)
		{
			var map = new Dictionary<object, object>
				{
					{"strength", Strength},
				};
			return new LuaTable(map);
		}

		public override LuaTable GetLuaTable(Mission mission)
		{
			var map = new Dictionary<object, object>
				{
					{"countdown",  Countdown??string.Empty},
				};
			return new LuaTable(map);
		}

		public override LuaTable GetLuaTable(Mission mission)
		{
			var map = new Dictionary<object, object>
				{
					{"group", Group},
				};
			return new LuaTable(map);
		}

		public override LuaTable GetLuaTable(Mission mission)
		{
			var map = new Dictionary<object, object>
				{
					{"playerNumber", mission.Players.IndexOf(Player)},
				};
			return new LuaTable(map);
		}

		public override LuaTable GetLuaTable(Mission mission)
		{
			var map = new Dictionary<object, object>
				{
					{"cutsceneID", CutsceneID},
				};
			return new LuaTable(map);
		}

 public void AddMission(string missionName,string description,List<float> missionValues)
 {
     Mission tempMission = new Mission();
     tempMission.name = missionName;
     tempMission.description = StringFormater.Format(description,20);
     tempMission.m_values = missionValues;
     missions.Add(tempMission);
 }