public static void InstallMod()
{
if (MoveItTool.instance == null)
{
// Creating the instance
ToolController toolController = GameObject.FindObjectOfType <ToolController>();
MoveItTool.instance = toolController.gameObject.AddComponent <MoveItTool>();
}
else
{
Debug.Log($"InstallMod with existing instance!");
}
MoveItTool.stepOver = new StepOver();
MoveItTool.m_debugPanel = new DebugPanel();
UIFilters.FilterCBs.Clear();
UIFilters.NetworkCBs.Clear();
Filters.Picker = new PickerFilter();
MoveItTool.filterBuildings = true;
MoveItTool.filterProps = true;
MoveItTool.filterDecals = true;
MoveItTool.filterSurfaces = true;
MoveItTool.filterTrees = true;
MoveItTool.filterNodes = true;
MoveItTool.filterSegments = true;
MoveItTool.filterNetworks = false;
IsGameLoaded = true;
}
public override void OnCreated(ILoading loading)
{
base.OnCreated(loading);
ToolController tc = UnityEngine.Object.FindObjectOfType <ToolController>();
tc?.gameObject?.AddComponent <TouchThisTool>();
}
// called when level is loaded
public void OnLevelLoaded(LoadMode mode)
{
//instatiate tools
if (RoundaboutTool.Instance == null || EllipseTool.Instance == null)
{
ToolController toolController = GameObject.FindObjectOfType <ToolController>();
RoundaboutTool.Instance = toolController.gameObject.AddComponent <RoundaboutTool>();
RoundaboutTool.Instance.enabled = false;
EllipseTool.Instance = toolController.gameObject.AddComponent <EllipseTool>();
EllipseTool.Instance.enabled = false;
FreeCursorTool.Instance = toolController.gameObject.AddComponent <FreeCursorTool>();
FreeCursorTool.Instance.enabled = false;
}
//instatiate UI
if (UIWindow2.instance == null) // !!
{
UIView.GetAView().AddUIComponent(typeof(UIWindow2));
}
/*if (NetInfoController.instance == null)
* {
* GameObject gameObject = new GameObject("RoundaboutBuilderNetinfoManager");
* NetInfoController.instance = gameObject.AddComponent<NetInfoController>();
* }*/
//Debug.Log(_string);
LevelLoaded = true;
//debug();
}
public static void InstallMod()
{
if (MoveItTool.instance == null)
{
// Creating the instance
ToolController toolController = GameObject.FindObjectOfType <ToolController>();
MoveItTool.instance = toolController.gameObject.AddComponent <MoveItTool>();
MoveItTool.stepOver = new StepOver();
UIFilters.FilterCBs.Clear();
UIFilters.NetworkCBs.Clear();
MoveItTool.filterBuildings = true;
MoveItTool.filterProps = true;
MoveItTool.filterDecals = true;
MoveItTool.filterSurfaces = true;
MoveItTool.filterTrees = true;
MoveItTool.filterNodes = true;
MoveItTool.filterSegments = true;
MoveItTool.filterNetworks = false;
}
IsGameLoaded = true;
}
// Use this for initialization
private void Start()
{
LevelController = new LevelController(FindObjectOfType <SceneLoader>());
GC = FindObjectOfType <GameController>();
ActionController = GetComponent <PlayerActionController>();
ToolController = GetComponent <ToolController>();
}
public override void OnLevelLoaded(LoadMode mode)
{
try
{
_loadMode = mode;
if (_loadMode != LoadMode.LoadGame && _loadMode != LoadMode.NewGame && _loadMode != LoadMode.NewGameFromScenario)
{
return;
}
ToolController toolController = UnityEngine.Object.FindObjectOfType <ToolController>();
if (toolController != null)
{
LocationTool.Instance = toolController.gameObject.AddComponent <LocationTool>();
}
UIView uiView = UnityEngine.Object.FindObjectOfType <UIView>();
if (uiView != null)
{
_mainPanelGameObject = new GameObject("NoteItMainPanel");
_mainPanelGameObject.transform.parent = uiView.transform;
_mainPanelGameObject.AddComponent <MainPanel>();
_locationPanelGameObject = new GameObject("NoteItLocationPanel");
_locationPanelGameObject.transform.parent = uiView.transform;
_locationPanelGameObject.AddComponent <LocationPanel>();
}
}
catch (Exception e)
{
Debug.Log("[Note It!] Loading:OnLevelLoaded -> Exception: " + e.Message);
}
}
public static T GetTool <T>(int sender) where T : ToolBase
{
ToolBase tool;
if (_currentTools.ContainsKey(sender))
{
tool = _currentTools[sender];
if (tool.GetType() == typeof(T))
{
return((T)tool);
}
}
tool = (ToolBase)Activator.CreateInstance(typeof(T));
ToolController controller = new ToolController();
ReflectionHelper.SetAttr(tool, "m_toolController", controller);
// See ToolController::Awake
ReflectionHelper.SetAttr(controller, "m_brushData", new float[4096]);
_currentTools[sender] = tool;
return((T)tool);
}
protected override void OnDeactivate(ToolController owner, GameObject target)
{
if (SalvComp == null | SwitchedTargets | !FinishedSalvage | OutOfRange)
{
return;
}
Debug.Log("Deactivated");
if (owner.PlayerInventory.AddToResourceBucket(SalvComp.SalvageItem, SalvComp.Amount))
{
//Debug.Log(owner.PlayerInventory.GetResourceAmount(SalvComp.SalvageItem.ResourceType));
Destroy(OriginalTarget);
//EVAN: Play salvaged success sound here
AkSoundEngine.PostEvent("SFX_Debris_Collect", target);
//resource gained pop text
Instantiate(popText).popText.SetText(SalvComp.SalvageItem.ResourceType.DisplayName + " Gained");
//Debug.Log("Salvaged Object");
}
else
{
Instantiate(popText).popText.SetText(SalvComp.SalvageItem.ResourceType.DisplayName + " Full");
}
//EVAN: finish the salvage sound
//error pop text
//Debug.Log("Not enough space");
SalvComp = null;
SwitchedTargets = true;
OriginalTarget = null;
}
public static void EndColliding(/*ulong[] ___m_collidingSegments1*/)
{
StackTrace stackTrace = new StackTrace();
ToolController targetInstance = Singleton <ToolManager> .instance.m_properties;
if (stackTrace.GetFrame(1).GetMethod().Name == "SimulationStep")
{
ulong[] ___m_collidingSegments1 = typeof(ToolController).GetField("m_collidingSegments1", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(targetInstance) as ulong[];
//UnityEngine.Debug.Log("EndColliding caller: " + stackTrace.GetFrame(2).GetMethod().GetUnderlyingType() + " " + stackTrace.GetFrame(2).GetMethod().Name + " " + ", count: " + CollidingSegments.Count);
CollidingSegments.Clear();
foreach (int segment in NetUtil.SegmentsFromMask(___m_collidingSegments1))
{
CollidingSegments.Add((ushort)segment);
}
CollidingSegmentsCache2 = CollidingSegments.ToArray();
}
Redirector <ToolControllerDetour> .Revert();
targetInstance.EndColliding();
Redirector <ToolControllerDetour> .Deploy();
//UnityEngine.Debug.Log("EndColliding: " + CollidingSegmentsCache2.Length);
}
public static void AddExtraToolsToController(ToolController toolController, List <ToolBase> extraTools)
{
if (extraTools.Count < 1)
{
return;
}
var fieldInfo = typeof(ToolController).GetField("m_tools", BindingFlags.Instance | BindingFlags.NonPublic);
var tools = (ToolBase[])fieldInfo.GetValue(toolController);
var initialLength = tools.Length;
Array.Resize(ref tools, initialLength + extraTools.Count);
var i = 0;
var dictionary =
(Dictionary <Type, ToolBase>)
typeof(ToolsModifierControl).GetField("m_Tools", BindingFlags.Static | BindingFlags.NonPublic)
.GetValue(null);
foreach (var tool in extraTools)
{
dictionary.Add(tool.GetType(), tool);
tools[initialLength + i] = tool;
i++;
}
fieldInfo.SetValue(toolController, tools);
}
void Start()
{
geometryBehaviour = GameObject.Find("/3D/Geometry").GetComponent <GeometryBehaviour>();
navigationBehaviour = GameObject.Find("/3D/Navigation").GetComponent <NavigationBehaviour>();
gridBehaviour = GameObject.Find("/3D/Grid").GetComponent <GridBehaviour>();
coordinateBehaviour = GameObject.Find("/3D/Coordinate").GetComponent <CoordinateBehaviour>();
geoCamera = GameObject.Find("/3D/GeoCamera").GetComponent <GeoCamera>();
navCamera = GameObject.Find("/3D/NavCamera").GetComponent <NavCamera>();
InitTouchSystem();
InitView();
InitUI();
geoCamera.InitDefault();
stateController = GetComponent <StateController>();
stateController.Init(geoUI.statePanel);
toolController = GetComponent <ToolController>();
toolController.Init(geoUI.toolPanel);
recognizeController = GetComponent <RecognizeController>();
recognizeController.Init(geoUI.writingPanel);
ClearGeometry();
}
public static void SetTool(this ToolController toolController, Type toolType)
{
if (!IsToolActive(toolController, toolType))
{
SetToolInternal(toolController, toolType);
}
}
public static void Initialize(ToolController toolController)
{
if (sm_initialized)
{
return;
}
Debug.Log("Traffic++: Initializing Transport Tool.\n");
TransportTool originalTransportTool = toolController.GetComponent <TransportTool>();
CustomTransportTool customTransportTool = toolController.gameObject.AddComponent <CustomTransportTool>();
// contributed by Japa
FieldInfo toolControllerField = typeof(ToolController).GetField("m_tools", BindingFlags.Instance | BindingFlags.NonPublic);
if (toolControllerField != null)
{
toolControllerField.SetValue(toolController, toolController.GetComponents <ToolBase>());
}
FieldInfo toolModifierDictionary = typeof(ToolsModifierControl).GetField("m_Tools", BindingFlags.Static | BindingFlags.NonPublic);
if (toolModifierDictionary != null)
{
toolModifierDictionary.SetValue(null, null);
}
sm_initialized = true;
Debug.Log("Traffic++: Transport Tool initialized.\n");
}
// Use this for initialization
private void Start()
{
ToolCtrl = FindObjectOfType <ToolController>();
TutorialUI = FindObjectOfType <TutorialUIController>();
SpaceBarUI = Instantiate(TutorialUI.PressSpaceImg, FindObjectOfType <Canvas>().transform);
SpaceBarUI.SetActive(false);
}
// Use this for initialization
void Start()
{
//hauteur d'un bloc
g_cubeHeight = 1.0f;
//distance entre le joueur et le cube
//g_cubeDistance = 3.0f;
//détermine si l'on est en train de dessiner un mur
g_isDrawingWall = false;
//détermine si l'on est en train de supprimer des blocs
g_isRemoving = false;
//sert à décrire l'état dans lequel le builder se trouve
g_currentMode = (int)g_modes.IDLE;
g_isPlayMode = false;
m_wallController = g_wallTool.GetComponent <wallController> ();
//m_removeController = g_removeTool.GetComponent<removeController> ();
//m_grabController = g_grabTool.GetComponent<grabController> ();
m_toolController = GetComponent <ToolController>();
m_colorController = GetComponent <colorController> ();
m_zoomController = GetComponent <zoomController> ();
m_rightWandController = g_rightController.GetComponent <wandController> ();
m_leftWandController = g_leftController.GetComponent <wandController> ();
}
protected override void OnSelect(ToolController owner)
{
Debug.Log("Satellite Tool Selected");
satInv = owner.GetComponent <SatelliteInventory>();
if (satInv == null || satInv.StoredSatellites.Count == 0 || satInv.StoredSatellites[0] == null)
{
satInv.NoSatTooltip.SetActive(true);
//Debug.Log("NoSat Found");
return;
}
//this is such a gross way of checking what satellite type a thing is im sorry
if (satInv.StoredSatellites[0].name == "FuelSatellite")
{
foreach (var cloud in cloudVisualizers)
{
cloud.VisualizeArea();
}
}
SatellitePreview = GameObject.Instantiate(satInv.StoredSatellites[0].PreviewPrefab);
SatellitePreview.transform.position = satInv.SatelliteSpawnPos.position;
SatellitePreview.transform.rotation = satInv.SatelliteSpawnPos.rotation;
SatellitePreview.transform.SetParent(owner.GetComponentInChildren <Camera>().transform);
SatBehavior = SatellitePreview.GetComponent <SatelliteBehavior>();
}
private void FreshPrefab(PrefabInfo info)
{
if (info != null)
{
ToolController properties = Singleton <ToolManager> .instance.m_properties;
var isAllowRun = false;
if (properties != null && properties.m_editPrefabInfo != null)
{
if (properties.m_editPrefabInfo.GetType() == typeof(VehicleInfo))
{
isAllowRun = true;
}
else if (properties.m_editPrefabInfo.GetType() == typeof(BuildingInfo))
{
isAllowRun = true;
}
else if (properties.m_editPrefabInfo.GetType() == typeof(PropInfo))
{
isAllowRun = true;
}
else if (properties.m_editPrefabInfo.GetType() == typeof(CitizenInfo))
{
isAllowRun = true;
}
}
if (isAllowRun)
{
try { AddHexColorsFields(); }
catch (Exception ex) { Debug.LogException(ex); }
}
}
}
//original as of 160815 2312
//private static List<ToolBase> SetupExtraTools(ref ToolController toolController)
//{
// List<ToolBase> toolBaseList = new List<ToolBase>();
// SetUpPropLineTool(ref toolController, ref toolBaseList);
// return toolBaseList;
//}
//new 160815 2312
private static bool SetupExtraTools(ref ToolController toolController, out List <ToolBase> extraTools)
{
List <ToolBase> _toolBaseList = new List <ToolBase>();
extraTools = _toolBaseList;
bool _setupPropLineToolResult = false;
_setupPropLineToolResult = SetUpPropLineTool(ref toolController, ref _toolBaseList);
//return false iff all extraTools already exist
if (_setupPropLineToolResult == false)
{
Debug.Log("[PLT]: ToolMan.SetupExtraTools(): Returning false...");
return(false);
}
else
{
extraTools = _toolBaseList;
Debug.Log("[PLT]: ToolMan.SetupExtraTools(): Returning true...");
return(true);
}
}
protected override void Handle(BuildingToolCreateCommand command)
{
BuildingTool tool = ToolSimulator.GetTool <BuildingTool>(command.SenderId);
IgnoreHelper.StartIgnore();
ArrayHandler.StartApplying(command.Array16Ids, command.Array32Ids);
BuildingInfo prefab = null;
if (command.Relocate == 0)
{
prefab = PrefabCollection <BuildingInfo> .GetPrefab(command.Prefab);
}
tool.m_prefab = prefab;
tool.m_relocate = command.Relocate;
ReflectionHelper.SetAttr(tool, "m_mousePosition", command.MousePosition);
ReflectionHelper.SetAttr(tool, "m_mouseAngle", command.MouseAngle);
ReflectionHelper.SetAttr(tool, "m_elevation", command.Elevation);
ReflectionHelper.SetAttr(tool, "m_placementErrors", ToolBase.ToolErrors.None);
ReflectionHelper.SetAttr(tool, "m_constructionCost", 0);
ToolController controller = ReflectionHelper.GetAttr <ToolController>(tool, "m_toolController");
ReflectionHelper.SetAttr(controller, "m_collidingSegments1", command.CollidingSegments);
ReflectionHelper.SetAttr(controller, "m_collidingBuildings1", command.CollidingBuildings);
ReflectionHelper.SetAttr(controller, "m_collidingDepth", 1);
ReflectionHelper.Call <IEnumerator>(tool, "CreateBuilding")?.MoveNext();
ArrayHandler.StopApplying();
IgnoreHelper.EndIgnore();
}
// called when level is loaded
public void OnLevelLoaded(LoadMode mode)
{
//instatiate tools
if (RoundaboutTool.Instance == null || EllipseTool.Instance == null)
{
ToolController toolController = GameObject.FindObjectOfType <ToolController>();
RoundaboutTool.Instance = toolController.gameObject.AddComponent <RoundaboutTool>();
RoundaboutTool.Instance.enabled = false;
EllipseTool.Instance = toolController.gameObject.AddComponent <EllipseTool>();
EllipseTool.Instance.enabled = false;
FreeCursorTool.Instance = toolController.gameObject.AddComponent <FreeCursorTool>();
FreeCursorTool.Instance.enabled = false;
}
//instatiate UI
if (UIWindow2.instance == null) // !!
{
UIView.GetAView().AddUIComponent(typeof(UIWindow2));
}
//update msg
if (!RoundAboutBuilder.SeenUpdateMsg)
{
UIWindow2.instance.ThrowErrorMsg("Roundabout Builder now supports undo! Yaay! Moreover, building costs are now taken from your account.\n" +
"Please report any bugs on the Steam Workshop page.");
RoundAboutBuilder.SeenUpdateMsg.value = true;
}
LevelLoaded = true;
}
protected override bool LoopCondition(ToolController owner, GameObject target)
{
SwitchedTargets = (OriginalTarget != target);
if (target == null)
{
return(false);
}
OutOfRange = Vector3.Distance(target.transform.position, owner.transform.position) >= _ToolRange;
if (OutOfRange)
{
progressBarFill.fillAmount = 0f;
ToggleBars(false);
}
if (!OutOfRange && progressBarBG.gameObject.activeSelf == false)
{
progressBarFill.fillAmount = 0f;
ToggleBars(true);
}
FinishedSalvage = ((SalvageStartTime + salvageTime) <= Time.unscaledTime);
if (!FinishedSalvage && !OutOfRange)
{
progressBarFill.fillAmount = ((Time.unscaledTime - SalvageStartTime) / (salvageTime));
//Debug.LogWarning(((Time.unscaledTime - SalvageStartTime )/ (salvageTime)));
}
else if (SwitchedTargets || FinishedSalvage || OutOfRange)
{
progressBarFill.fillAmount = 0f;
ToggleBars(false);
}
return(!(OutOfRange || SwitchedTargets || FinishedSalvage));
}
protected override bool ActivateCondition(ToolController owner, GameObject target)
{
if (SatBehavior == null || target == null)
{
return(false);
}
return(SatBehavior.PlacementConditionCheck(owner) && (satInv.StoredSatellites[0] != null));
}
protected override void OnDeselect(ToolController owner)
{
//Debug.Log("Salvager DeSelected");
SalvComp = null; //cleanup
ToggleBars(false);
progressBarBG = null;
progressBarFill = null;
}
public static bool IsToolActive(this ToolController toolController, Type toolType)
{
if (toolController.CurrentTool == null)
{
return(false);
}
return(toolController.CurrentTool.GetType() == toolType);
}
protected override bool LoopCondition(ToolController owner, GameObject target)
{
if (healthComponent == null || target == null)
{
Debug.LogWarning("Nothing to repair");
return(false);
}
return(healthComponent.CanRepair(owner.gameObject) && inventoryComponent.GetResource(RepairNaniteResource) >= NanitesPerCycle);
}
/// <summary>
/// Detour for ToolManager.EndRenderingImpl
/// </summary>
private void EndRenderingImpl(RenderManager.CameraInfo cameraInfo)
{
ToolController properties = Singleton <ToolManager> .instance.m_properties;
if (properties != null)
{
PrefabInfo editPrefabInfo = properties.m_editPrefabInfo;
if (editPrefabInfo != null)
{
VehicleInfo vehicleInfo = editPrefabInfo as VehicleInfo;
if (vehicleInfo != null)
{
// Modified implementation
RenderInfo(cameraInfo, vehicleInfo, new Vector3(0f, 60f, 0f), false);
if (vehicleInfo.m_trailers != null)
{
// Bug(?) fix: main info's m_attachOffsetBack did not get applied
float num = vehicleInfo.m_generatedInfo.m_size.z * 0.5f - vehicleInfo.m_attachOffsetBack;
for (int i = 0; i < vehicleInfo.m_trailers.Length; i++)
{
VehicleInfo info = vehicleInfo.m_trailers[i].m_info;
// New: Support correct display of inverted trailers
bool isInverted = (vehicleInfo.m_trailers[i].m_invertProbability >= 100);
float frontDelta = info.m_generatedInfo.m_size.z * 0.5f - info.m_attachOffsetFront;
float backDelta = info.m_generatedInfo.m_size.z * 0.5f - info.m_attachOffsetBack;
num += isInverted ? backDelta : frontDelta;
Vector3 position = new Vector3(0f, 60f, 0f) + new Vector3(0f, 0f, -num);
RenderInfo(cameraInfo, info, position, isInverted);
// Change for inverted vehicles
num += isInverted ? frontDelta : backDelta;
}
}
}
else
{
//Default
editPrefabInfo.RenderMesh(cameraInfo);
}
}
try
{
ToolBase currentTool = properties.CurrentTool;
if (currentTool != null)
{
currentTool.RenderGeometry(cameraInfo);
}
}
catch (Exception ex)
{
UIView.ForwardException(ex);
CODebugBase <LogChannel> .Error(LogChannel.Core, "Tool error: " + ex.Message + "\n" + ex.StackTrace);
}
}
}
// Use this for initialization
private void Start()
{
StatusCtrl = GetComponent <PatientStatusController>();
TutorialUI = FindObjectOfType <TutorialUIController>();
ToolCtrl = FindObjectOfType <ToolController>();
AilmentCtrl = GetComponent <AilmentController>();
SpaceBarImg = Instantiate(TutorialUI.HoldSpaceImg, FindObjectOfType <Canvas>().transform);
SpaceBarImg.SetActive(false);
}
private void Start()
{
gooGlueBar.SetActive(false);
if (player == null)
{
player = UIRoot.GetPlayer();
}
playerTools = player.GetComponent <ToolController>();
PopulateToolbar();
}
public override void OnLevelLoaded(LoadMode mode)
{
if (MoveItTool.instance == null)
{
// Creating the instance
ToolController toolController = GameObject.FindObjectOfType <ToolController>();
MoveItTool.instance = toolController.gameObject.AddComponent <MoveItTool>();
}
}
private void saveButton_Click(object sender, EventArgs e)
{
ToolController.SavePlaylist(this);
if (SaveConfirmHandle != null)
{
SaveConfirmHandle();
}
Close();
}
public void Start()
{
m_view = UIView.GetAView();
m_selectAIPanel = m_view.FindUIComponent<SelectAIPanel>("SelectAIPanel");
m_uiContainer = m_view.FindUIComponent("FullScreenContainer");
m_propPanel = m_uiContainer.Find<UIPanel>("DecorationProperties");
m_toolController = ToolsModifierControl.toolController;
m_selectAIPanel.eventValueChanged += OnAIFieldChanged;
m_toolController.eventEditPrefabChanged += OnEditPrefabChanged;
}
public static void AddExtraToolsToController(ToolController toolController, List<ToolBase> extraTools)
{
if (extraTools.Count < 1)
{
return;
}
var fieldInfo = typeof(ToolController).GetField("m_tools", BindingFlags.Instance | BindingFlags.NonPublic);
var tools = (ToolBase[])fieldInfo.GetValue(toolController);
var initialLength = tools.Length;
Array.Resize(ref tools, initialLength + extraTools.Count);
var i = 0;
var dictionary =
(Dictionary<Type, ToolBase>)
typeof(ToolsModifierControl).GetField("m_Tools", BindingFlags.Static | BindingFlags.NonPublic)
.GetValue(null);
foreach (var tool in extraTools)
{
dictionary.Add(tool.GetType(), tool);
tools[initialLength + i] = tool;
i++;
}
fieldInfo.SetValue(toolController, tools);
}
//returns false in no extra tools were set up
public static List<ToolBase> SetUpExtraTools(LoadMode mode, ToolController toolController)
{
var extraTools = new List<ToolBase>();
if (mode == LoadMode.LoadGame || mode == LoadMode.NewGame || mode == LoadMode.NewGameFromScenario)
{
LoadResources();
if (SetUpToolbars(mode))
{
if (OptionsWrapper<Options>.Options.waterTool)
{
SetUpWaterTool(extraTools);
}
SetupBrushOptionsPanel(OptionsWrapper<Options>.Options.treeBrush);
var optionsPanel = Object.FindObjectOfType<BrushOptionPanel>();
if (optionsPanel != null)
{
optionsPanel.m_BuiltinBrushes = toolController.m_brushes;
if (OptionsWrapper<Options>.Options.resourcesTool || OptionsWrapper<Options>.Options.terrainTool)
{
SetUpNaturalResourcesTool(extraTools);
}
if (OptionsWrapper<Options>.Options.terrainTool)
{
SetUpTerrainToolExtensionss();
}
}
}
}
try
{
var pluginTools = Plugins.SetupTools(mode);
extraTools.AddRange(pluginTools);
}
catch (Exception e)
{
UnityEngine.Debug.LogException(e);
}
return extraTools;
}
void Start()
{
GameObject scripts = GameObject.Find("Scripts");
toolController = (ToolController)scripts.GetComponent("ToolController");
}
