internal override ZipPackageRelationship CreateRelationship(Uri targetUri, TargetMode targetMode, string relationshipType)
        {

            var rel = base.CreateRelationship(targetUri, targetMode, relationshipType);
            rel.SourceUri = Uri;
            return rel;
        }

		protected void OnEnable()
		{
#if UNITY_4_6 || UNITY_4_7 || UNITY_4_8 || UNITY_4_9 || UNITY_5_0
			this.title = "SP Reference Replacer";
#else
            this.titleContent = new GUIContent("SP Reference Replacer");
#endif
            if (EditorPrefs.HasKey(SPTools.Settings_SavedInstanceIDKey))
			{
				string instancePath = AssetDatabase.GetAssetPath(EditorPrefs.GetInt(SPTools.Settings_SavedInstanceIDKey, 0));
				
				if (!string.IsNullOrEmpty(instancePath))
				{
					this.m_Instance = AssetDatabase.LoadAssetAtPath(instancePath, typeof(SPInstance)) as SPInstance;
				}
			}
			
			// Default prefs
			if (!EditorPrefs.HasKey(SPReferenceReplacerWindow.PrefsKey_TargetMode))
			{
				EditorPrefs.SetInt(SPReferenceReplacerWindow.PrefsKey_TargetMode, (int)this.m_TargetMode);
			}
			
			// Load target mode setting
			this.m_TargetMode = (TargetMode)EditorPrefs.GetInt(SPReferenceReplacerWindow.PrefsKey_TargetMode);
		}

    private void BottomRight()
    {
        GUI.skin = leftRight;
        GUI.BeginGroup(new Rect(Screen.width - 300, Screen.height - 300, 300, 300));
        GUI.DrawTexture(new Rect(0, 0, 300, 300), bgImage, ScaleMode.StretchToFill);

        if (GameVars.selectedTurret != null)
        {
            Tower selectedTower = GameVars.selectedTurret.GetComponent<Tower>();
            targetMode = (TargetMode)GUI.SelectionGrid(new Rect(40, 40, 180, 50), (int)targetMode, selectionStrings, 2);
            damage = GUI.HorizontalSlider(new Rect(30, 100, 130, 30), selectedTower.Damage, 1.0f, selectedTower.maxPoints);
            speed = GUI.HorizontalSlider(new Rect(30, 130, 130, 30), selectedTower.Speed, 1.0f, selectedTower.maxPoints);
            range = GUI.HorizontalSlider(new Rect(30, 160, 130, 30), selectedTower.Range, 1.0f, selectedTower.maxPoints);
            GUI.Label(new Rect(170, 90, 200, 100), "Damage: " + (int)damage);
            GUI.Label(new Rect(170, 120, 200, 100), "Speed: " + (int)speed);
            GUI.Label(new Rect(170, 150, 200, 100), "Range: " + (int)range);

            //if anything has changed, update it
            if (damage != selectedTower.Damage) { GameVars.selectedTurret.GetComponent<Tower>().Damage = damage; }
            if (speed != selectedTower.Speed) { GameVars.selectedTurret.GetComponent<Tower>().Speed = speed; }
            if (range != selectedTower.Range) { GameVars.selectedTurret.GetComponent<Tower>().Range = range; }
            if (targetMode != selectedTower.targetingMode) { GameVars.selectedTurret.GetComponent<Tower>().targetingMode = targetMode; }
        }
        GUI.EndGroup();
    }

    public void Fire(TargetMode mode, MagicSpawner magazine)
    {
        if (!isActive) return;

        if (magazine.IsLoaded) {
            magazine.Fire (GetTarget (mode));
        }
    }

 public Transform GetTarget(TargetMode mode)
 {
     if (mode == TargetMode.Single) {
         return primaryTarget;
     } else {
         return targetList.RandomOrDefault ();
     }
 }

 internal virtual ZipPackageRelationship CreateRelationship(Uri targetUri, TargetMode targetMode, string relationshipType)
 {
     var rel = new ZipPackageRelationship();
     rel.TargetUri = targetUri;
     rel.TargetMode = targetMode;
     rel.RelationshipType = relationshipType;
     rel.Id = "rId" + (maxRId++).ToString();
     _rels.Add(rel);
     return rel;
 }

    // Use this for initialization
    void Start()
    {
        if(targetMode==TargetMode.Transform&&targetTransform==null)targetMode = TargetMode.Point;
        trans = transform;

        #if UNITY_EDITOR
        curPosA = new Vector3[numPoints+1];
        firstAxisA = new Vector3[numPoints+1];
        secondAxisA = new Vector3[numPoints+1];
        #endif
    }

        internal PackageRelationship(string id, Package package, string relationshipType,
                                      Uri sourceUri, TargetMode targetMode, Uri targetUri)
        {
            Check.IdIsValid(id);
            Check.Package(package);
            Check.RelationshipTypeIsValid(relationshipType);
            Check.SourceUri(sourceUri);
            Check.TargetUri(targetUri);

            Id = id;
            Package = package;
            RelationshipType = relationshipType;
            SourceUri = sourceUri;
            TargetMode = targetMode;
            TargetUri = targetUri;
        }

    public void Slam(Vector3 target)
    {
        if (hasTarget) return;

        targetMode = TargetMode.SLAM;
        Vector3 start = transform.position;
        start.x = Mathf.Clamp(start.x, transform.parent.position.x + minX, transform.parent.position.x + maxX);
        Vector3 end = target;
        end.x = Mathf.Clamp(end.x, transform.parent.position.x + minX, transform.parent.position.x + maxX);
        end.y = start.y;
        Vector3 b = new Vector3(start.x, start.y + maxHeight * 0.5f);
        Vector3 c = new Vector3(end.x, start.y + maxHeight);
        Vector3[] points = new Vector3[] { start, b, c, end };
        bezier = new CubicBezier(points);
        hasTarget = true;
        progress = 0.01f;
    }

        /**
         * Constructor.
         * 
         * @param pkg
         * @param sourcePart
         * @param targetUri
         * @param targetMode
         * @param relationshipType
         * @param id
         */
        public PackageRelationship(OPCPackage pkg, PackagePart sourcePart,
                Uri targetUri, TargetMode targetMode, String relationshipType,
                String id)
        {
            if (pkg == null)
                throw new ArgumentException("pkg");
            if (targetUri == null)
                throw new ArgumentException("targetUri");
            if (relationshipType == null)
                throw new ArgumentException("relationshipType");
            if (id == null)
                throw new ArgumentException("id");

            this.container = pkg;
            this.source = sourcePart;
            this.targetUri = targetUri;
            this.targetMode = targetMode;
            this.relationshipType = relationshipType;
            this.id = id;
        }

 /// <summary>
 /// Adds a relationship to this PackagePart with the Target PackagePart specified as the Uri
 /// Initial and trailing spaces in the name of the PackageRelationship are trimmed.
 /// </summary>
 /// <param name="targetUri"></param>
 /// <param name="targetMode">Enumeration indicating the base uri for the target uri</param>
 /// <param name="relationshipType">PackageRelationship type, having uri like syntax that is used to 
 /// uniquely identify the role of the relationship</param>
 /// <param name="id">String that conforms to the xsd:ID datatype. Unique across the source's
 /// relationships. Null is OK (ID will be generated). An empty string is an invalid XML ID.</param>
 /// <returns></returns>
 /// <exception cref="InvalidOperationException">If this part has been deleted</exception>
 /// <exception cref="InvalidOperationException">If the parent package has been closed or disposed</exception>
 /// <exception cref="IOException">If the package is readonly, it cannot be modified</exception>
 /// <exception cref="ArgumentNullException">If parameter "targetUri" is null</exception>
 /// <exception cref="ArgumentNullException">If parameter "relationshipType" is null</exception>
 /// <exception cref="ArgumentOutOfRangeException">If parameter "targetMode" enumeration does not have a valid value</exception>
 /// <exception cref="ArgumentException">If TargetMode is TargetMode.Internal and the targetUri is an absolute Uri </exception>
 /// <exception cref="ArgumentException">If relationship is being targeted to a relationship part</exception>
 /// <exception cref="System.Xml.XmlException">If parameter "id" is not a valid Xsd Id</exception>
 /// <exception cref="System.Xml.XmlException">If an id is provided in the method, and its not unique</exception>
 public PackageRelationship CreateRelationship(Uri targetUri, TargetMode targetMode, string relationshipType, String id)
 {
     CheckInvalidState();
     _container.ThrowIfReadOnly();
     EnsureRelationships();
     //All parameter validation is done in the following method
     return _relationships.Add(targetUri, targetMode, relationshipType, id);
 }

        public void RunProject(TargetMode target)
        {
            MainForm mainForm = FindForm() as MainForm;
            if (mainForm == null || mainForm.SettingsModel == null)
                return;

            Process.Start("http://localhost:" + mainForm.SettingsModel.RunnerHttpServerPort.ToString() + '/' + target.ToString());
        }

        /**
         * Add a relationship to a part (except relationships part).
         * <p>
         * Check rule M1.25: The Relationships part shall not have relationships to
         * any other part. Package implementers shall enforce this requirement upon
         * the attempt to create such a relationship and shall treat any such
         * relationship as invalid.
         * </p>
         * @param targetURI
         *            URI of the target part. Must be relative to the source root
         *            directory of the part.
         * @param targetMode
         *            Mode [Internal|External].
         * @param relationshipType
         *            Type of relationship.
         * @param id
         *            Relationship unique id.
         * @return The newly created and added relationship
         * 
         * @throws InvalidFormatException
         *             If the URI point to a relationship part URI.
         * @see org.apache.poi.OpenXml4Net.opc.RelationshipSource#AddRelationship(org.apache.poi.OpenXml4Net.opc.PackagePartName,
         *      org.apache.poi.OpenXml4Net.opc.TargetMode, java.lang.String, java.lang.String)
         */
        public PackageRelationship AddRelationship(Uri targetURI,
                TargetMode targetMode, String relationshipType, String id)
        {
            container.ThrowExceptionIfReadOnly();

            if (targetURI == null)
            {
                throw new ArgumentException("targetPartName");
            }
            //if (targetMode == null)
            //{
            //    throw new ArgumentException("targetMode");
            //}
            if (relationshipType == null)
            {
                throw new ArgumentException("relationshipType");
            }

            // Try to retrieve the target part

            if (this.IsRelationshipPart
                    || PackagingUriHelper.IsRelationshipPartURI(targetURI))
            {
                throw new InvalidOperationException(
                        "Rule M1.25: The Relationships part shall not have relationships to any other part.");
            }

            if (relationships == null)
            {
                relationships = new PackageRelationshipCollection();
            }

            return relationships.AddRelationship(targetURI,
                    targetMode, relationshipType, id);
        }

		internal PackageRelationship CreateRelationship (Uri targetUri, TargetMode targetMode, string relationshipType, string id, bool loading)
		{
			if (!loading)
				CheckIsReadOnly ();
			
			Check.TargetUri (targetUri);
			if (targetUri.IsAbsoluteUri && targetMode == TargetMode.Internal)
				throw new ArgumentException ("TargetUri cannot be absolute for an internal relationship");
			
			Check.RelationshipTypeIsValid (relationshipType);
			Check.IdIsValid (id);

			if (id == null)
				id = NextId ();

			PackageRelationship r = new PackageRelationship (id, this, relationshipType, Uri, targetMode, targetUri);

			if (!PartExists (RelationshipUri))
				CreatePartCore (RelationshipUri, RelationshipContentType, CompressionOption.NotCompressed).IsRelationship = true;
			
			Relationships.Add (r.Id, r);
			relationshipsCollection.Relationships.Add (r);

			if (!loading) {
				using (Stream s = GetPart (RelationshipUri).GetStream ())
					WriteRelationships (relationships, s);
			}
			
			return r;
		}

 /// <summary>
 /// Creates a relationship at the Package level with the Target PackagePart specified as the Uri
 /// </summary>
 /// <param name="targetUri">Target's URI</param>
 /// <param name="targetMode">Enumeration indicating the base uri for the target uri</param>
 /// <param name="relationshipType">PackageRelationship type, having uri like syntax that is used to
 /// uniquely identify the role of the relationship</param>
 /// <param name="id">String that conforms to the xsd:ID datatype. Unique across the source's
 /// relationships. Null is OK (ID will be generated). An empty string is an invalid XML ID.</param>
 /// <returns></returns>
 /// <exception cref="ObjectDisposedException">If this Package object has been disposed</exception>
 /// <exception cref="IOException">If the package is readonly, it cannot be modified</exception>
 /// <exception cref="ArgumentNullException">If parameter "targetUri" is null</exception>
 /// <exception cref="ArgumentNullException">If parameter "relationshipType" is null</exception>
 /// <exception cref="ArgumentOutOfRangeException">If parameter "targetMode" enumeration does not have a valid value</exception>
 /// <exception cref="ArgumentException">If TargetMode is TargetMode.Internal and the targetUri is an absolute Uri </exception>
 /// <exception cref="ArgumentException">If relationship is being targeted to a relationship part</exception>
 /// <exception cref="System.Xml.XmlException">If parameter "id" is not a valid Xsd Id</exception>
 /// <exception cref="System.Xml.XmlException">If an id is provided in the method, and its not unique</exception>
 public PackageRelationship CreateRelationship(Uri targetUri, TargetMode targetMode, string relationshipType, String id)
 {
     ThrowIfObjectDisposed();
     ThrowIfReadOnly();
     EnsureRelationships();
     //All parameter validation is done in the following call
     return _relationships.Add(targetUri, targetMode, relationshipType, id);
 }

        protected void OnGUI()
        {
            EditorGUIUtility.labelWidth = 100f;

            GUILayout.BeginVertical();
            GUILayout.Space((float)SPReferenceReplacerWindow.padding.top);
            GUILayout.BeginHorizontal();
            GUILayout.Space((float)SPReferenceReplacerWindow.padding.left);
            GUILayout.BeginVertical();

            GUI.changed = false;
            this.m_Instance = EditorGUILayout.ObjectField("Sprite Packer", this.m_Instance, typeof(SPInstance), false) as SPInstance;
            if (GUI.changed)
            {
                // Save the instance id
                EditorPrefs.SetInt(SPTools.Settings_SavedInstanceIDKey, (this.m_Instance == null) ? 0 : this.m_Instance.GetInstanceID());
            }

            GUILayout.Space(6f);

            GUILayout.BeginVertical(GUI.skin.box);
            GUILayout.Space(6f);

            GUILayout.BeginHorizontal();
            GUILayout.Space(6f);

            EditorGUILayout.LabelField("Replace mode", GUILayout.Width(130f));
            this.m_ReplaceMode = (ReplaceMode)EditorGUILayout.EnumPopup(this.m_ReplaceMode);

            GUILayout.Space(6f);
            GUILayout.EndHorizontal();

            GUILayout.BeginHorizontal();
            GUILayout.Space(6f);

            EditorGUI.BeginChangeCheck();
            EditorGUILayout.LabelField("Replace references in", GUILayout.Width(130f));
            this.m_TargetMode = (TargetMode)EditorGUILayout.EnumPopup(this.m_TargetMode);
            if (EditorGUI.EndChangeCheck())
            {
                EditorPrefs.SetInt(SPReferenceReplacerWindow.PrefsKey_TargetMode, (int)this.m_TargetMode);
            }

            GUILayout.Space(6f);
            GUILayout.EndHorizontal();

            GUILayout.BeginHorizontal();
            GUILayout.Space(6f);
            GUI.changed = false;
            bool spriteRenderersOnly = GUILayout.Toggle(EditorPrefs.GetBool(SPReferenceReplacerWindow.PrefsKey_SpriteRenderersOnly), " Replace references in Sprite Renderers only ?");
            if (GUI.changed)
            {
                EditorPrefs.SetBool(SPReferenceReplacerWindow.PrefsKey_SpriteRenderersOnly, spriteRenderersOnly);
            }
            GUILayout.Space(6f);
            GUILayout.EndHorizontal();

            GUILayout.Space(6f);
            GUILayout.EndVertical();

            GUILayout.Space(6f);

            if (this.m_Instance == null)
            {
                EditorGUILayout.HelpBox("Please set the sprite packer instance reference in order to use this feature.", MessageType.Info);
            }
            else
            {
                if (GUILayout.Button("Replace"))
                {
                    int replacedCount = 0;

                    switch (this.m_TargetMode)
                    {
                    case TargetMode.CurrentScene:
                    {
                        replacedCount += SPTools.ReplaceReferencesInScene(this.m_Instance.copyOfSprites, this.m_ReplaceMode, spriteRenderersOnly);
                        break;
                    }
                    case TargetMode.ProjectOnly:
                    {
                        replacedCount += SPTools.ReplaceReferencesInProject(this.m_Instance.copyOfSprites, this.m_ReplaceMode, spriteRenderersOnly);
                        break;
                    }
                    case TargetMode.CurrentSceneAndProject:
                    {
                        replacedCount += SPTools.ReplaceReferencesInProject(this.m_Instance.copyOfSprites, this.m_ReplaceMode, spriteRenderersOnly);
                        replacedCount += SPTools.ReplaceReferencesInScene(this.m_Instance.copyOfSprites, this.m_ReplaceMode, spriteRenderersOnly);
                        break;
                    }
                    case TargetMode.AllScenes:
                    {
                        replacedCount += SPTools.ReplaceReferencesInAllScenes(this.m_Instance.copyOfSprites, this.m_ReplaceMode, spriteRenderersOnly, false);
                        break;
                    }
                    case TargetMode.AllScenesAndProject:
                    {
                        replacedCount += SPTools.ReplaceReferencesInProject(this.m_Instance.copyOfSprites, this.m_ReplaceMode, spriteRenderersOnly);
                        replacedCount += SPTools.ReplaceReferencesInScene(this.m_Instance.copyOfSprites, this.m_ReplaceMode, spriteRenderersOnly);
                        EditorApplication.SaveScene();
//.........这里部分代码省略.........

        //------------------------------------------------------
        //
        //  Public Methods
        //
        //------------------------------------------------------
        // None
        //------------------------------------------------------
        //
        //  Public Events
        //
        //------------------------------------------------------
        // None
        //------------------------------------------------------
        //
        //  Internal Constructors
        //
        //------------------------------------------------------

        #region Internal Constructor

        /// <summary>
        /// PackageRelationship constructor
        /// </summary>
        /// <param name="package">Owning Package object for this relationship</param>
        /// <param name="sourcePart">owning part - will be null if the owner is the container</param>
        /// <param name="targetUri">target of relationship</param>
        /// <param name="targetMode">enum specifying the interpretation of the base uri for the target uri</param>
        /// <param name="relationshipType">type name</param>
        /// <param name="id">unique identifier</param>
        internal PackageRelationship(Package package, PackagePart sourcePart, Uri targetUri, TargetMode targetMode, string relationshipType, string id)
        {
            //sourcePart can be null to represent that the relationships are at the package level

            if (package == null)
                throw new ArgumentNullException("package");

            if (targetUri == null)
                throw new ArgumentNullException("targetUri");

            if (relationshipType == null)
                throw new ArgumentNullException("relationshipType");

            if (id == null)
                throw new ArgumentNullException("id");
            // The ID is guaranteed to be an XML ID by the caller (InternalRelationshipCollection).
            // The following check is a precaution against future bug introductions.
#if DEBUG
            try
            {
                // An XSD ID is an NCName that is unique. We can't check uniqueness at this level.
                XmlConvert.VerifyNCName(id);
            }
            catch (XmlException exception)
            {
                throw new XmlException(Formatter.Format(Resources.NotAValidXmlIdString, id), exception);
            }
#endif

            // Additional check - don't accept absolute Uri's if targetMode is Internal.
            Debug.Assert((targetMode == TargetMode.External || !targetUri.IsAbsoluteUri),
                "PackageRelationship target must be relative if the TargetMode is Internal");

            // Additional check - Verify if the Enum value is valid
            Debug.Assert((targetMode >= TargetMode.Internal || targetMode <= TargetMode.External),
                "TargetMode enum value is out of Range");

            // Look for empty string or string with just spaces
            Debug.Assert(relationshipType.Trim() != String.Empty,
                "RelationshipType cannot be empty string or a string with just spaces");

            _package = package;
            _source = sourcePart;
            _targetUri = targetUri;
            _relationshipType = relationshipType;
            _targetMode = targetMode;
            _id = id;
        }

 public void Sweep(Vector3 target)
 {
     targetMode = TargetMode.SWEEP;
     sweepStart = transform.position;
     sweepStart.y = minY;
     sweepTarget = target;
     sweepTarget.y = minY;
     hasTarget = true;
     progress = 0.01f;
 }

        public void CleanProject(TargetMode target)
        {
            MainForm mainForm = FindForm() as MainForm;
            if (mainForm == null || mainForm.SettingsModel == null || mainForm.ProjectModel == null)
                return;

            if (m_runningProcess != null && !m_runningProcess.HasExited)
            {
                MetroMessageBox.Show(mainForm, "Cannot clean " + target.ToString() + " " + " because another operation is running!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            string path = Path.Combine(Path.GetFullPath(mainForm.ProjectModel.WorkingDirectory), "bin", target.ToString());
            if (Directory.Exists(path))
            {
                Directory.Delete(path, true);
                MetroMessageBox.Show(mainForm, target.ToString() + " build cleaned!", "Operation Complete!", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            else
                MetroMessageBox.Show(mainForm, target.ToString() + " build does not exists!", "Operation Error!", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }

		private PackageRelationship CreateRelationship (Uri targetUri, TargetMode targetMode, string relationshipType, string id, bool loading)
		{
			Package.CheckIsReadOnly ();
			Check.TargetUri (targetUri);
			Check.RelationshipTypeIsValid (relationshipType);
			Check.IdIsValid (id);

			if (id == null)
				id = NextId ();

			if (Relationships.ContainsKey (id))
				throw new XmlException ("A relationship with this ID already exists");
			
			PackageRelationship r = new PackageRelationship (id, Package, relationshipType, Uri, targetMode, targetUri);
			Relationships.Add (r.Id, r);

			if (!loading)
				WriteRelationships ();
			return r;
		}