public void OnInteraction( Tool tool )
 {
     if( tool.GetType() == typeof(HandTool) )
     {
         Talk( tool.transform.root.gameObject );
     }
 }

        public void Init()
        {
            player1Observer = new MockObserver("Player1 Observer");
            fullPlayerObserver = new MockObserver("FullPlayer Observer");
            player1InventoryObserver = new MockObserver("Player 1 Inventory Observer");
            fullPlayerInventoryObserver = new MockObserver("FullPlayer Inventory Observer");

            player1 = new Player ("Player1", Gender.FEMALE, "Eve2", new Vector2 (0, 0));
            player1.AddObserver(player1Observer);

            fullPlayer = new Player ("Ollie", Gender.MALE, "Evan1", Vector2.zero);
            fullPlayer.InitialiseInventory (20);
            fullPlayer.AddObserver(fullPlayerObserver);
            fullPlayer.Inventory.AddObserver(fullPlayerInventoryObserver);

            for (int i = 0; i < 20; i++) {
                InventoryItem item = new InventoryItem();
                item.ItemName = "Item" + i;
                item.ItemId = i;
                item.ItemType = ItemType.RUBBISH;
                item.ItemDescription = string.Empty;
                fullPlayer.AddItem(item);
            }

            tool1 = new MockTool("Tool1");
            tool2 = new MockTool("Tool2");
            tool3 = new MockTool("Tool3");

            fullPlayer.AddTool(tool1);
            fullPlayer.AddTool(tool2);
            fullPlayer.AddTool(tool3);
        }

    void ChangeTool( GameObject obj )
    {
        if( null == obj )
        {
            Debug.Log( "Cannot change tool to null object" );
            return;
        }

        if( obj == m_EquippedTool )
        {
            Debug.Log( "Cannot change to tool - this tool is currently equipped" );
            return;
        }

        Tool nextTool = GetToolScript( obj );
        if( null == nextTool )
        {
            Debug.Log( "Cannot locate tool script on object" );
            return;
        }

        m_PreviousTool = m_EquippedTool;
        m_PreviousToolScript = m_EquippedToolScript;
        m_EquippedTool = obj;
        m_EquippedToolScript = nextTool;

        m_EquippedToolScript.Attach();

        if( m_PreviousToolScript )
            m_PreviousToolScript.Detach();
    }

	void OnEnable() {
		if (paintButTexOn==null) paintButTexOn=AssetDatabase.LoadAssetAtPath("Assets/ReliefPack/Editor/ReliefTerrain/icons/icoPaintOn.png", typeof(Texture)) as Texture;
		if (paintButTexOff==null) paintButTexOff=AssetDatabase.LoadAssetAtPath("Assets/ReliefPack/Editor/ReliefTerrain/icons/icoPaintOff.png", typeof(Texture)) as Texture;
		
		prev_tool=UnityEditor.Tools.current;
		
		GeometryVsTerrainBlend _target=(GeometryVsTerrainBlend)target;
		if (_target.orig_mesh==null) {
			MeshFilter mf=_target.GetComponent(typeof(MeshFilter)) as MeshFilter;
			//if (AssetDatabase.GetAssetPath(mf.sharedMesh)!="") {
				_target.orig_mesh = mf.sharedMesh;	
			//}
		}
		if (!_target.blendedObject) {
			MeshFilter mf=_target.GetComponent(typeof(MeshFilter)) as MeshFilter;
		  	RaycastHit[] hits;
			hits=Physics.RaycastAll(_target.transform.position+_target.transform.up*20, -_target.transform.up, 100);
			int o;
			for(o=0; o<hits.Length; o++) {
				bool  ReliefTerrainBlended=hits[o].collider.gameObject.GetComponent(typeof(ReliefTerrain))!=null;
				bool  VoxelTerrainBlended=hits[o].collider.gameObject.GetComponent(typeof(ReliefTerrainVertexBlendTriplanar))!=null;
				if (ReliefTerrainBlended || VoxelTerrainBlended) {
					_target.VoxelBlendedObject=VoxelTerrainBlended;
					_target.blendedObject=hits[o].collider.gameObject;
					CheckShaderForBlendCapability();
					_target.MakeMeshCopy();
					_target.pmesh=mf.sharedMesh;
					EditorUtility.SetDirty(target);
					SceneView.RepaintAll();
					break;
				}
			}
		}		
	}

    //Tool manipulation is a way to prevent the transform handles from appearing
    void OnEnable()
    {
        generatedMesh = target as MeshGen2D;

        lastTool = Tools.current;
        Tools.current = Tool.None;
    }

        /// <summary>
        /// Interface implementation that takes a Static Driver Verifier log stream and converts
        ///  its data to a SARIF json stream. Read in Static Driver Verifier data from an input
        ///  stream and write Result objects.
        /// </summary>
        /// <param name="input">Stream of a Static Driver Verifier log</param>
        /// <param name="output">SARIF json stream of the converted Static Driver Verifier log</param>
        public override void Convert(Stream input, IResultLogWriter output)
        {
            if (input == null)
            {
                throw new ArgumentNullException(nameof(input));
            }

            if (output == null)
            {
                throw new ArgumentNullException(nameof(output));
            }

            Result result = ProcessSdvDefectStream(input);
            var results = new Result[] { result };

            var tool = new Tool
            {
                Name = "StaticDriverVerifier",
            };

            var fileInfoFactory = new FileInfoFactory(null);
            Dictionary<string, FileData> fileDictionary = fileInfoFactory.Create(results);

            output.Initialize(id: null, correlationId: null);

            output.WriteTool(tool);
            if (fileDictionary != null && fileDictionary.Count > 0) { output.WriteFiles(fileDictionary); }

            output.OpenResults();
            output.WriteResults(results);
            output.CloseResults();
        }

 public override void OnInteraction(Tool tool)
 {
     if (tool is Hand)
     {
         numpad.OnNumPadButtonPressed(number);
     }
 }

 public PanTool(Level pointer, Tool prevTool, Point startPoint)
     : base(pointer)
 {
     this.pointer = pointer;
     this.prevTool = prevTool;
     this.startPoint = startPoint;
 }

        /// <summary>
        /// Converts a Semmle log file in CSV format to a SARIF log file.
        /// </summary>
        /// <param name="input">
        /// Input stream from which to read the Semmle log.
        /// </param>
        /// <param name="output">
        /// Output string to which to write the SARIF log.
        /// </param>
        /// <exception cref="ArgumentNullException">
        /// Thrown when one or more required arguments are null.
        /// </exception>
        public override void Convert(Stream input, IResultLogWriter output)
        {
            if (input == null)
            {
                throw new ArgumentNullException(nameof(input));
            }

            if (output == null)
            {
                throw new ArgumentNullException(nameof(output));
            }

            _toolNotifications = new List<Notification>();

            var results = GetResultsFromStream(input);

            var tool = new Tool
            {
                Name = "Semmle"
            };

            output.Initialize(id: null, correlationId: null);

            output.WriteTool(tool);

            output.OpenResults();
            output.WriteResults(results);
            output.CloseResults();

            if (_toolNotifications.Any())
            {
                output.WriteToolNotifications(_toolNotifications);
            }
        }

        public string HashPassword(Tool tor, string password)
        {
            var process = new Process
            {
                StartInfo =
                {
                    FileName = tor.ExecutablePath,
                    Arguments = $"--hash-password {password}",
                    RedirectStandardOutput = true,
                    UseShellExecute = false
                }
            };

            var sb = new StringBuilder();
            process.OutputDataReceived += (sender, args) => sb.AppendLine(args.Data);

            process.Start();
            process.BeginOutputReadLine();
            process.WaitForExit();

            return sb
                .ToString()
                .Split('\n')
                .Select(l => l.Trim())
                .Last(l => l.Length > 0);
        }

 public override void OnInteraction(Tool tool)
 {
     if (tool is Hand)
     {
         rgbMachine.OnRGBButtonPressed(rgbValue);
     }
 }

	/// <summary>
	/// Sets the tool to block with a specific block
	/// </summary>
	/// <param name="name">Name of block</param>
	public void SetToolBlock(string name) {
		tool = Tool.Block;
		BlockCursor.SetBlock(new Block[,,] { { { BlockManager.GetBlock(name) } } });
		BlockCursor.offset = Vector3.zero;

		VRCursor.SetBlock(new Block[,,] { { { BlockManager.GetBlock(name) } } });
	}

        protected override void SolveInstance(IGH_DataAccess DA)
        {
            string name = null;
            GH_Plane tcp = null;
            double weight = 0;
            GH_Mesh mesh = null;
            GH_Point centroid = null;
            List<GH_Plane> planes = new List<GH_Plane>();

            if (!DA.GetData(0, ref name)) { return; }
            if (!DA.GetData(1, ref tcp)) { return; }
            DA.GetDataList(2, planes);
            if (!DA.GetData(3, ref weight)) { return; }
            DA.GetData(4, ref centroid);
            DA.GetData(5, ref mesh);

            var tool = new Tool(tcp.Value, name, weight, centroid?.Value, mesh?.Value);

            if (planes.Count > 0)
            {
                if (planes.Count != 4)
                    this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, " Calibration input must be 4 planes");
                else
                    tool.FourPointCalibration(planes[0].Value, planes[1].Value, planes[2].Value, planes[3].Value);
            }

            DA.SetData(0, new GH_Tool(tool));
            DA.SetData(1, tool.Tcp);
        }

 /// <summary>
 /// Returns true if this adorner provider supports the tool passed in.
 /// By default this returns true for SelectionTool.
 /// </summary>
 /// <param name="tool">Tool to be checked.</param>
 /// <returns>true if the tool passed in is supported.</returns>
 public override bool IsToolSupported(Tool tool)
 {
     if (tool is SelectionTool || tool is CreationTool)
     {
         return true;
     }
     return false;
 }

    void OnInteraction( Tool tool )
    {
        Console.Instance.addGameChatMessage( "Saving..." );

        if( tool.GetType() == typeof( HandTool ) )
        {
        }
    }

        public ToolTab(Tool tool, AnchorStyles anchor, Orientation orientation)
        {
            if(tool == null) throw new ArgumentNullException("tool");

            _tool = tool;
            _anchor = anchor;
            _orientation = orientation;
        }

 public override void OnInteraction(Tool tool)
 {
     if (tool is ScrewDriver)
     {
         this.Defuse();
         StartCoroutine(RemoveScrew());
     }
 }

		private void ResetToolSelection( Tool tool ) {
			if( tool != Tool.Select )
				ChkArrow.Checked = false;
			if( tool != Tool.Fill )
				ChkFill.Checked = false;
			if( tool != Tool.Unfill )
				ChkBordering.Checked = false;
		}

    public void CollectMaterial(CollectionMethod method, Tool tool)
    {
        var parameter = new Dictionary<byte, object> {
                             { (byte)CollectMaterialParameterItem.CollectiontMethod, method},
                             { (byte)CollectMaterialParameterItem.ToolID, (tool == null) ? ItemID.No : tool.id}
                        };

        peer.OpCustom((byte)OperationType.CollectMaterial, parameter, true, 0, true);
    }

 public override void OnInteraction(Tool tool)
 {
     if ( tool is Hand)
     {
         this.Defuse();
         StartCoroutine(MoveLever());
         switchInner.SetLeverState(this.gameObject.name, leverUp);
     }
 }