public ToolItem(ToolType type, int stackSize = 1) : base("", "", 1.0f, ItemCategory.Tools, stackSize) { ToolType = type; Icon = ToolType.ToString(); switch (ToolType) { case ToolType.Pickaxe: Name = "Pickaxe"; Description = "Tool used for mining stone."; break; case ToolType.Shovel: Name = "Shovel"; Description = "Tool used for excavating earth."; break; case ToolType.Axe: Name = "Axe"; Description = "Tool used for chopping trees."; break; case ToolType.Hammer: Name = "Hammer"; Description = "Tool used for crafting mechanics."; break; case ToolType.DroneChain: Name = "Chain Drone"; Description = "Drone used for creating chains of vertical digging constraints."; break; default: Debug.Fail("Unknown tool type"); break; } }
public void DragActivityOnDropPoint(ToolType toolType) { UITestControl dropPoint = VisualTreeWalker.GetChildByAutomationIdPath(Activity, "SmallViewContent", "DropPoint"); var boundingRectangle = dropPoint.BoundingRectangle; ToolboxUIMap.DragControlToWorkflowDesigner(toolType, new Point(boundingRectangle.X + 10, boundingRectangle.Y + 10)); }
public async Task CreateToolTypeSearchAsync(ToolType toolType) { var tts = new ToolTypeSearch { Name = toolType.Name, RefId = toolType.Id, Categories = toolType.MainType, Services = toolType.Serves }; List <string> keyWords = new List <string>(); // Add All Key Words // add name //keyWords.Add(toolType.Name.ToUpper()); // ToolType.Name // add serves foreach (var serve in toolType.Serves) { keyWords.Add(serve.ToUpper() + " "); // ToolTypes.Serves } tts.KeyWords = keyWords.ToArray(); await _toolTypesSearch.InsertOneAsync(tts); }
public SpawnPointPicker() { _Image = new BitmapImage(new Uri(@"pack://application:,,,/TEdit;component/Images/Tools/spawn.png")); _Name = "Spawn Point Tool"; _Type = ToolType.Pencil; IsActive = false; }
/// <summary> /// Konstruktor /// </summary> /// <param name="name">Name des Tools</param> /// <param name="controlident">Eindeutiger Identifier im gesammten Programmsystem für DIESES Tool</param> /// <param name="initcode">Der LaserScript Init Code</param> /// <param name="tt">Der Typ des zu erstellenden Tools</param> public Tool(string name, string controlident, ToolType tt) : base(name, controlident) { CameraOffset = new PointXD <int>(2); MyToolType = tt; Load(); }
private void SelectTool(ToolType toolType) { SelectedToolType = toolType; DialogResult = true; Close(); }
public Selection() { _Image = new BitmapImage(new Uri(@"pack://application:,,,/TEdit;component/Images/Tools/shape_square.png")); _Name = "Selection"; _Type = ToolType.Selection; IsActive = false; }
public void ChangeTool(ToolType toolType) { if (toolType == type) { return; } _type = toolType; if (toolType == ToolType.None) { _tool = null; } else if (toolType == ToolType.Translation) { _tool = TRANSLATION_TOOL; } else if (toolType == ToolType.Rotation) { _tool = ROTATION_TOOL; } else if (toolType == ToolType.Scaling) { _tool = SCALING_TOOL; } else if (toolType == ToolType.VertexTranslation) { _tool = VERTEX_TRANSLATION_TOOL; } _tool?.Reset(); OnToolChanged(new ToolChangedEventArgs(toolType)); }
public void DragActivityOnLargeViewDropPoint(ToolType toolType) { UITestControl dropPoint = VisualTreeWalker.GetChildByAutomationIdPath(Activity, "LargeViewContent", "ActivitiesPresenter"); var boundingRectangle = dropPoint.BoundingRectangle; ToolboxUIMap.DragControlToWorkflowDesigner(toolType, new Point(boundingRectangle.X + 10, boundingRectangle.Y + 10)); }
public ToolDescriptor(Guid id, IWarewolfType designer, IWarewolfType activity, string name, string icon, Version version, bool isSupported, string category, ToolType toolType, string iconUri, string filterTag, string toolTip, string helpText) { if (id == Guid.Empty) { throw new ArgumentNullException("id", "empty guids not allowed fo tools"); } VerifyArgument.AreNotNull(new Dictionary <string, object> { { "id", id }, { "designer", designer }, { "activity", activity }, { "name", name }, { "icon", icon }, { "version", version }, { "category", category }, { iconUri, "iconUri" }, { filterTag, "filterTag" } }); ToolType = toolType; Category = category; IsSupported = isSupported; Version = version; Icon = icon; Name = name; Activity = activity; IconUri = iconUri; Designer = designer; Id = id; FilterTag = filterTag; ResourceToolTip = toolTip; ResourceHelpText = helpText; }
public void SwitchTool(ToolType tool) { m_currentTool = tool; switch (tool) { case ToolType.HAMMER: m_spriteRenderer.sprite = m_hammerSprite; break; case ToolType.HAND: m_spriteRenderer.sprite = m_handSprite; break; case ToolType.MAGICWAND: m_spriteRenderer.sprite = m_wandSprite; break; case ToolType.HOTGLUE: m_spriteRenderer.sprite = m_caulkingGunSprite; break; case ToolType.DUCKTAPE: m_spriteRenderer.sprite = m_ducktapeSprite; break; case ToolType.PLASTER: m_spriteRenderer.sprite = m_plasterSpreaderSprite; break; } toolChanged(tool); }
private void inkPanel_MouseUp(object sender, MouseButtonEventArgs e) { DrawCommand command = new DrawCommand(currentShape, inkPanel); undoRedo.InsertComand(command); if (!btnEraser.IsChecked.Value) { draw(e); } else if (btnEraser.IsChecked.Value) { currentTool = ToolType.Ellipse; draw(e); } if (e.LeftButton == MouseButtonState.Pressed && !btnEraser.IsChecked.Value) { inkPanel.Children.Remove(currentShape); } /*else if (e.LeftButton == MouseButtonState.Released && previousMouseEvent == MouseButtonState.Pressed) * {*/ //} previousMouseEvent = e.LeftButton; }
private async Task <Utility.Process.Result?> RunToolInternal(ToolType tool, List <string>?args, bool?useShell, CancellationToken cancellationToken, bool lowPriority) { // always include the prepend args List <string> full_args = GetArgsToPrepend(); if (args is not null) { full_args.AddRange(args); } string tool_path = GetToolExecutable(tool); if (useShell is null) { useShell = ShouldUseShell(tool, args); } if (useShell.Value) { return(await Utility.Process.StartProcessWithShell(BaseDirectory, tool_path, full_args, cancellationToken, lowPriority)); } else { return(await Utility.Process.StartProcess(BaseDirectory, tool_path, full_args, cancellationToken, lowPriority)); } }
public void SetTool(ToolType toolType) { Tool nextTool; if (!toolList.TryGetValue(toolType, out nextTool)) { Console.WriteLine("No matching tool found for :: {0}", toolType); return; } if (!nextTool.Initialize()) { return; } if (_currentTool != null) { foreach (var worldObject in WorldObjects) { _currentTool.Remove(worldObject); } } foreach (var worldObject in WorldObjects) { nextTool.Apply(worldObject); } _currentTool = nextTool; }
public Tool(string name, string internal_name, int durability, float weight, float volyme, string ui_sprite, SpriteManager.SpriteType ui_sprite_type, ToolType type, int level, float efficiency) : base(name, internal_name, durability, weight, volyme, ui_sprite, ui_sprite_type) { Type = type; Level = level; Base_Efficiency = efficiency; }
public Paste() { _Image = new BitmapImage(new Uri(@"pack://application:,,,/TEdit;component/Images/Tools/paste.png")); _Name = "Paste"; _Type = ToolType.Selection; _IsActive = false; }
public void BtnMoveScreenEllipse_OnClick(object sender, RoutedEventArgs e) { ToolType currentTooltype = PocketPaintApplication.GetInstance().ToolCurrent.GetToolType(); if (currentTooltype != ToolType.Move) { //PocketPaintApplication.GetInstance().PaintingAreaView.setVisibilityGrdSliderThickness(Visibility.Collapsed); PocketPaintApplication.GetInstance().SwitchTool(ToolType.Move); PocketPaintApplication.GetInstance().PaintingAreaView.changeVisibilityOfSelectionsControls(Visibility.Collapsed); PocketPaintApplication.GetInstance().PaintingAreaView.changeBackgroundColorAndOpacityOfPaintingAreaCanvas(Colors.Transparent, 1.0); } else if (currentTooltype == ToolType.Move) { if (PocketPaintApplication.GetInstance().ToolWhileMoveTool == null) { return; } ToolType newSelectedTooltype = PocketPaintApplication.GetInstance().ToolWhileMoveTool.GetToolType(); PocketPaintApplication.GetInstance().SwitchTool(newSelectedTooltype); PocketPaintApplication.GetInstance().PaintingAreaView.changeVisibilityOfActiveSelectionControl(Visibility.Visible); if (newSelectedTooltype == ToolType.Ellipse || newSelectedTooltype == ToolType.ImportPng || newSelectedTooltype == ToolType.Rect) { PocketPaintApplication.GetInstance().PaintingAreaView.changeBackgroundColorAndOpacityOfPaintingAreaCanvas(Colors.Black, 0.5); } PocketPaintApplication.GetInstance().PaintingAreaView.resetActiveSelectionControl(); } }
/// <summary> /// Konstruktor /// </summary> /// <param name="name">Name des Tools</param> /// <param name="controlident">Eindeutiger Identifier im gesammten Programmsystem für DIESES Tool</param> /// <param name="initcode">Der LaserScript Init Code</param> /// <param name="tt">Der Typ des zu erstellenden Tools</param> public Tool(string name, string controlident, ToolType tt) : base(name, controlident) { CameraOffset = new PointXD<int>(2); MyToolType = tt; Load(); }
/// <summary> /// Replaces the default cursor image depending on the current editing state /// and tool. /// </summary> void ToggleCursor() { if (!IsMouseInEditingArea()) { CursorController.PopCursor(crosshairId); return; } // Transform editor is responsible for setting the cursor. Return. if (transformEditor.IsDragging()) { return; } ToolType current = toolbarController.toolbar.GetActiveTool(); if (current != ToolType.SelectionTool) { if (CursorController.GetCurrentId() < crosshairId) { crosshairId = CursorController.PushCursor(cursorCrosshair, new Vector2(17.5f, 17.5f)); } } else { CursorController.PopCursor(crosshairId); } }
// Update is called once per frame void Update() { if (Keyboard.current.qKey.isPressed) { this.CurrentToolType = ToolType.Pan; } else if (Keyboard.current.wKey.isPressed) { this.CurrentToolType = ToolType.Rotate; } if (action.Desktop.Pan.phase == InputActionPhase.Started) { // pan var firingPos = action.Desktop.Aim.ReadValue <Vector2>(); this.transform.position += startPlaneDownPos - GetGroundPosition(firingPos); } if (action.Desktop.Rotate.phase == InputActionPhase.Started) { // rotate var firingPos = action.Desktop.Aim.ReadValue <Vector2>(); deltaFiringPos = prevFiringPos - firingPos; prevFiringPos = firingPos; var prevRotation = this.transform.localRotation.eulerAngles; float xAxisRotation = prevRotation.x + deltaFiringPos.y / RotationFactor; float yAxisRotation = prevRotation.y - deltaFiringPos.x / RotationFactor; this.transform.localRotation = Quaternion.Euler(xAxisRotation, yAxisRotation, 0); } }
private void correctRecordsStatus(DataTable table) { for (int i = 0; i < table.Rows.Count; ++i) { DataRow row = table.Rows[i]; if (row.RowState == DataRowState.Modified) { bool changed = false; for (int c = 0; c < table.Columns.Count; ++c) { object cur = row[c]; object orj = row[c, DataRowVersion.Original]; if (!ToolType.isEqual(cur, orj)) { changed = true; break; } } if (!changed) { row.AcceptChanges(); } } } }
public void LargeViewTextboxesEnterTestData(ToolType tool, UITestControl theTab) { //Find the start point UITestControl theStartButton = WorkflowDesignerUIMap.FindControlByAutomationId(theTab, "Start"); Point workflowPoint1 = new Point(theStartButton.BoundingRectangle.X, theStartButton.BoundingRectangle.Y + 200); // Drag the tool onto the workflow ToolboxUIMap.DragControlToWorkflowDesigner(tool, workflowPoint1); WorkflowDesignerUIMap.OpenCloseLargeView(tool, theTab); // Add the data! List<UITestControl> listOfTextboxes = GetAllTextBoxesFromLargeView(tool.ToString(), theTab); int counter = 0; foreach(var textbox in listOfTextboxes) { WpfEdit tb = textbox as WpfEdit; if(tb != null && !tb.IsPassword) { tb.SetFocus(); SendKeys.SendWait("[[theVar" + counter.ToString(CultureInfo.InvariantCulture) + "]]"); } counter++; } }
public async Task <IActionResult> Edit(int id, [Bind("ToolTypeId,Name")] ToolType toolType) { if (id != toolType.ToolTypeId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(toolType); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ToolTypeExists(toolType.ToolTypeId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(toolType)); }
public void init(string id, int index, string name, string desc, ToolType tlType, Sprite img, bool upgrades = true) { this.index = index; this.id = id; el_name.text = name; el_img.sprite = img; this.toolType = tlType; this.upgrades = upgrades; el_upgradeMeter.gameObject.SetActive (upgrades); if (upgrades) { int upgdLevel = StoreInventory.GetGoodUpgradeLevel (id); if(upgdLevel==5){ el_desc.text = LanguageManager.current.getText(LanguageNode.FullUpgraded); buy.gameObject.SetActive(false); el_upgradeMeter.fillAmount = 1f; }else{ el_desc.text = desc; el_price.text = AnimineStoreAssets.UPGRADE_PRICE [upgdLevel]+""; buy.onClick.AddListener(()=>{ _OnElementBuy(); }); } el_upgradeMeter.fillAmount = upgdLevel / 5f; } else { el_desc.text = desc; el_price.text = AnimineStoreAssets.TOOLS_PRICE[(int)toolType]+""; buy.onClick.AddListener(()=>{ _OnElementBuy(); }); } }
public Arrow() { _Image = new BitmapImage(new Uri(@"pack://application:,,,/TEdit;component/Images/Tools/cursor.png")); _Name = "Arrow"; _Type = ToolType.Arrow; IsActive = false; }
/// <summary> /// Create a ITool from an string and XElement. /// </summary> /// <param name="assemblyType"> The type for assembly. </param> /// <param name="type"> The source type. </param> /// <returns> The created ITool. </returns> public static ITool CreateTool(Type assemblyType, ToolType type) { if (XML.Tools.ContainsKey(type)) { return(XML.Tools[type]); } if (type != ToolType.None) { Assembly assembly = assemblyType.GetTypeInfo().Assembly; IEnumerable <TypeInfo> typeInfos = assembly.DefinedTypes; TypeInfo typeInfo = typeInfos.FirstOrDefault(t => t.FullName == $"Retouch_Photo2.Tools.Models.{type}Tool"); if ((typeInfo is null) == false) { object obj = Activator.CreateInstance(typeInfo.AsType()); if (obj is ITool tool) { XML.Tools.Add(type, tool); return(tool); } } } return(new NoneTool()); }
/// <summary> /// Drags a control from the Toolbox to the Workflow /// </summary> /// <param name="toolName">The name of the control you to drag - Eg: Assign, Calculate, Etc</param> /// <param name="tabToDropOnto">The tab on which to drop the control</param> /// <param name="pointToDragTo">The point you wish to drop the control</param> /// <param name="getDroppedActivity">Get and return the dropped control</param> public UITestControl DragControlToWorkflowDesigner(ToolType tool, UITestControl tabToDropOnto, Point pointToDragTo = new Point(), bool getDroppedActivity = true) { UITestControl theControl = FindToolboxItemByAutomationId(tool); theControl.WaitForControlEnabled(); if(pointToDragTo.X == 0 && pointToDragTo.Y == 0) { UITestControl theStartButton = WorkflowDesignerUIMap.FindStartNode(tabToDropOnto); pointToDragTo = new Point(theStartButton.BoundingRectangle.X, theStartButton.BoundingRectangle.Y + 200); } Mouse.StartDragging(theControl, MouseButtons.Left); Playback.Wait(20); Mouse.StopDragging(pointToDragTo); Playback.Wait(100); UITestControl resourceOnDesignSurface = null; if(getDroppedActivity) { resourceOnDesignSurface = WorkflowDesignerUIMap.FindControlByAutomationId(tabToDropOnto, tool.ToString()); int counter = 0; while(resourceOnDesignSurface == null && counter < 5) { Playback.Wait(1000); resourceOnDesignSurface = WorkflowDesignerUIMap.FindControlByAutomationId(tabToDropOnto, tool.ToString()); Playback.Wait(500); counter++; } } return resourceOnDesignSurface; }
/* * Converts enum types we use in this class to equivalent types in the Tool script from the original project * */ private ToolType OptionToTool() { ToolType tType = ToolType.None; switch (toolType) { case ToolOptionType.Reset: tType = ToolType.Reset; break; case ToolOptionType.Rotate: tType = ToolType.Rotate; break; case ToolOptionType.Tilt: tType = ToolType.Pan; break; case ToolOptionType.Zoom: tType = ToolType.Zoom; break; default: Debug.LogError("Invalid Tool Type"); break; } return(tType); }
public FloodFill() { _Image = new BitmapImage(new Uri(@"pack://application:,,,/TEdit;component/Images/Tools/paintcan.png")); _Name = "Flood Fill"; _Type = ToolType.Pencil; IsActive = false; }
public void LargeViewTextboxesEnterTestData(ToolType tool, UITestControl theTab) { //Find the start point UITestControl theStartButton = WorkflowDesignerUIMap.FindControlByAutomationId(theTab, "Start"); Point workflowPoint1 = new Point(theStartButton.BoundingRectangle.X, theStartButton.BoundingRectangle.Y + 200); // Drag the tool onto the workflow ToolboxUIMap.DragControlToWorkflowDesigner(tool, workflowPoint1); WorkflowDesignerUIMap.OpenCloseLargeView(tool, theTab); // Add the data! List <UITestControl> listOfTextboxes = GetAllTextBoxesFromLargeView(tool.ToString(), theTab); int counter = 0; foreach (var textbox in listOfTextboxes) { WpfEdit tb = textbox as WpfEdit; if (tb != null && !tb.IsPassword) { tb.SetFocus(); SendKeys.SendWait("[[theVar" + counter.ToString(CultureInfo.InvariantCulture) + "]]"); } counter++; } }
public UserToolPickedUpEvent(ToolType toolType, Int32 x, Int32 y, Int32 index) { this.ToolType = toolType; this.X = x; this.Y = y; this.Index = index; }
/// <summary> /// Function that determines what happens when the player is hit by another player's tool. /// </summary> /// <param name="toolTransform">Position of the other player.</param> /// <param name="toolType">Type of tool hit by.</param> /// <param name="toolMode">Tool mode hit by.</param> public override void HitByTool(PlayerServer player, Transform toolTransform, ToolType toolType, ToolMode toolMode) { if (!Dead) { base.HitByTool(player, toolTransform, toolType, toolMode); } }
public override void HandleHit(ToolType toolType) { if (toolType == ToolType.Hammer || toolType == ToolType.Rock) { if (m_audioSource) { m_audioSource.Play(); } } if (toolType == ToolType.Hammer)//hammer hits better { m_hits += m_hammerHitValue; } else if (toolType == ToolType.Rock) { m_hits += m_rockHitValue; } if (m_hits >= m_hitsPerRock) { if (m_rocks == 2)//last hit -> instantiate 2 rocks and destroy self { Instantiate(m_rockPrefab, m_rockSpawn.position, m_rockSpawn.rotation); Instantiate(m_rockPrefab, m_rockSpawn.position, m_rockSpawn.rotation); Destroy(gameObject); return; } Instantiate(m_rockPrefab, m_rockSpawn.position, m_rockSpawn.rotation); m_hits = 0; --m_rocks; } }
public bool Damage(ToolType toolType, ToolMaterial toolMaterial) { if (toolType.CanHarvest(this.toolType) && toolMaterial.StrongEnough(this.toolMaterial)) { float multiplier = toolType.RightTool(this.toolType) ? toolMaterial.Multiplier : 1; currentDamage += Time.deltaTime * multiplier * 0.666666f; if (currentDamage >= totalDamage) { if (destroyed) { return(true); } destroyed = true; ItemEntity.Spawn(transform.position, item, 1); } } else { currentDamage += Time.deltaTime * 0.2f; } if (currentDamage >= totalDamage) { destroyed = true; OnDestroyed(); Destroy(gameObject); return(true); } return(false); }
public void CreateToolTypeSearch(string toolTypeName) { ToolType toolType = _toolTypes.Find(toolType => toolType.Name.Equals(toolTypeName)).FirstOrDefault(); var tts = new ToolTypeSearch { Name = toolType.Name, RefId = toolType.Id, Categories = toolType.MainType, Services = toolType.Serves }; List <string> keyWords = new List <string>(); // Add All Key Words // add name //keyWords.Add(toolType.Name.ToUpper()); // ToolType.Name // add serves foreach (var serve in toolType.Serves) { keyWords.Add(serve.ToUpper()); // ToolTypes.Serves } tts.KeyWords = keyWords.ToArray(); _toolTypesSearch.InsertOne(tts); }
private void toolChange(object sender, RoutedEventArgs e) { switch ((tool.SelectedItem as ComboBoxItem).Name) { case "Line": currentTool = ToolType.Line; break; case "Ellipse": currentTool = ToolType.Ellipse; break; case "Rectangle": currentTool = ToolType.Rectangle; break; case "Triangle": currentTool = ToolType.Triangle; break; default: break; } setMode(); }
/// <summary> /// 向流程中添加工具,需要根据选择的工具名对工具类型等进行判断 /// </summary> /// <param name="tool">工具类型</param> /// <param name="isInsert">插入位置,当为-1时,表示在末尾插入,当不为-1时,表示被插入的工具索引</param> public void Add_Tool(ToolType tool, int insertPos = -1, int imageKey = 0) { string toolName = GetNewToolName(tool.ToString()); IToolInfo insertTool = VisionToolFactory.CreateToolVision(tool, toolName); TreeNode insertNode = new TreeNode(); insertNode = VisionJobParams.myJobTreeView.Nodes.Add("", insertTool.toolName, (int)tool, (int)tool); // 该工具对应的节点 // 判断节点是否添加默认输入输出图 // 输入 for (int i = 0; i < insertTool.toolInput.Count; i++) { TreeNode childrenInputNode = insertNode.Nodes.Add("<--" + insertTool.toolInput[i].IOName); childrenInputNode.Tag = insertTool.toolInput[i].ioType; childrenInputNode.ForeColor = Color.DarkMagenta; } // 输出 for (int i = 0; i < insertTool.toolOutput.Count; i++) { TreeNode childrenOutputNode = insertNode.Nodes.Add("-->" + insertTool.toolOutput[i].IOName); childrenOutputNode.Tag = insertTool.toolOutput[i].ioType; childrenOutputNode.ForeColor = Color.Blue; } insertNode.Expand(); VisionJobParams.myVisionJob.L_toolList.Add(insertTool); }
private void ongui() { if (isLoaded) { gui.label(new Vector2(0, 100), string.Format("depth: {0}", currentMapDepth)); gui.label(new Vector2(0, 120), string.Format("noise: {0}", noiseAmount)); //if (input.WasKeyPressed(Keys.)) // selectedTool = ToolType.None; if (input.WasKeyPressed(Keys.D1)) { selectedTool = ToolType.DigWall; } //graphics.Draw(spriteSheetMaterial, AxisAlignedBox.FromRect(0, 400, 32, 32), AxisAlignedBox.FromRect(0, 96, 32, 32), selectedTool == ToolType.Dig ? Color.White : Color.Gray); if (isSelecting) { //var miso = mouseIso; gui.label(new Vector2(0, 140), string.Format("")); } gui.label(new Vector2(0, 160), "Tool: "); //gui.label2(AxisAlignedBox.FromRect(100, 200, 150, 150), new GUIContent("1234 1234 1234 1234", new GUITexture() { material = resources.createMaterialFromTexture("content/textures/ship.png") })); //gui.label2(AxisAlignedBox.FromRect(100, 500, 300, 300), new GUIContent("1234", new GUITexture() { material = resources.createMaterialFromTexture("content/textures/ship.png") })); } }
public override void HandleHit(ToolType toolType) { if (toolType == ToolType.Hammer || toolType == ToolType.Rock) { if (m_audioSource) { m_audioSource.Play(); } } if (toolType == ToolType.Hammer) // hammer better hits { m_hits -= 2; } else if (toolType == ToolType.Rock) { m_hits -= 1; } if (m_hits <= 0) {// instantiate two stone fragments and destroy self Instantiate(m_fragmentPrefab, transform.position, transform.rotation); Instantiate(m_fragmentPrefab, transform.position, transform.rotation); Destroy(gameObject); } }
internal Tool(uint index, ToolType toolType) { _index = index; _toolType = toolType; UpdateToolStatus(); ID = toolType == ToolType.Item ? index : 0; }
public Pencil() { _image = new BitmapImage(new Uri(@"pack://application:,,,/TEdit;component/Images/Tools/pencil.png")); _name = "Pencil"; _type = ToolType.Pencil; _isActive = false; }
public MainForm() { currentUndo = null; selectedTile = null; undoBuffer = new Stack<UndoState>(); redoBuffer = new Stack<UndoState>(); selectedTool = ToolType.SELECTOR; InitializeComponent(); UpdateUndoRedoItems(); attributePaletteForm = new AttributePalette(); attributePaletteForm.Owner = this; createRoomDialog = new CreateRoomDialog(); createRoomDialog.Owner = this; GDIUtils.SetDoubleBuffered(this); this.tileSetPanel1.TileSelected += new TileSetPanel.TileSelectedHandler(HandleTileSelection); var toolButtons = this.toolStrip.Items; foreach (ToolStripItem item in toolButtons) { item.Click += new EventHandler(HandleToolStripItemClick); } SetShowAttributes(false); }
/// <summary> /// Tool type selection /// </summary> private void m_btnSelection_Click(object sender, EventArgs e) { btnPointer.Checked = false; btnRectangle.Checked = false; btnEllipse.Checked = false; btnPolygon.Checked = false; ToolStripButton tsBtn = (ToolStripButton)sender; tsBtn.Checked = true; switch (tsBtn.Name) { case "btnCursor": this._selectAction = ToolType.Pointer; break; case "btnRectangle": this._selectAction = ToolType.Rectangle; break; case "btnEllipse": this._selectAction = ToolType.Ellipse; break; case "btnPolygon": this._selectAction = ToolType.Polygon; break; default: this._selectAction = ToolType.Pointer; break; } _owner.ToolbarCommandChanged(this._selectAction); }
/// <summary> /// Drags a control from the Toolbox to the Workflow /// </summary> /// <param name="controlId">The name of the control you to drag - Eg: Assign, Calculate, Etc</param> /// <param name="p">The point you wish to drop the control - Point p = WorkflowDesignerUIMap.GetPointUnderStartNode("someWorkflow"); is a good palce to start</param> /// <param name="searchID">The search unique identifier.</param> public void DragControlToWorkflowDesigner(ToolType tool, Point p, string searchID = "") { UITestControl theControl = FindToolboxItemByAutomationId(tool, searchID); theControl.WaitForControlEnabled(); Playback.Wait(100); Mouse.StartDragging(theControl, MouseButtons.Left); Mouse.StopDragging(p); }
void Start() { currentTool = ToolType.brush; saltToolUsed = false; saltToolActivated = false; saltHealth = STARTING_HEALTH; saltCurrentlyTurnedOff = false; }
public Brush() { _lastUsedSize = new SizeInt32(0, 0); _image = new BitmapImage(new Uri(@"pack://application:,,,/TEdit;component/Images/Tools/paintbrush.png")); _name = "Brush"; _type = ToolType.Brush; _isActive = false; }
public ActivationInfo(ToolSlot slot, ToolType type, bool state, string propertyName, float propertyValue) { Slot = slot; State = state; Type = type; PropertyName = propertyName; PropertyValue = propertyValue; }
public ToolPlacedEvent(ToolType toolType, Actor toolActor, Int32 x, Int32 y, Int32 index) { this.ToolType = toolType; this.ToolActor = toolActor; this.X = x; this.Y = y; this.Index = index; }
public static ToolCommandBase Create(ToolType tool, ArchitectToolControler toolControler, ArchitectTilePositionGetter getter) { switch (tool) { case ToolType.Brush: return new BrushCommand(getter, toolControler.SelectedTileType, toolControler.RotationFlip); //case ToolType.Eraser: return new EraserTool(architect, getter); } return null; }
/// <summary> /// Create opening on wall /// </summary> /// <param name="points">Points use to create Opening</param> /// <param name="type">Tool type</param> public override void DrawOpening(List<Vector4> points, ToolType type) { //get the rectangle two points Autodesk.Revit.DB.XYZ p1 = new Autodesk.Revit.DB.XYZ (points[0].X, points[0].Y, points[0].Z); Autodesk.Revit.DB.XYZ p2 = new Autodesk.Revit.DB.XYZ (points[2].X, points[2].Y, points[2].Z); //draw opening on wall m_docCreator.NewOpening(m_data, p1, p2); }
public static void ActivateTool(ToolType toolType) { _gameData.ToolCounts[(int)toolType] -= 1; switch (toolType) { case ToolType.FireExtinguisher: _gameData.ToolActiveTimeRemaining = Constants.Fire_Extinguisher_Duration; break; } }
public Tool GetTool(ToolType type, object[] arguments) { Type toolType = _toolConstructors[type]; var argumentTypes = GetArgumentTypes(arguments); var constructor = toolType.GetConstructor(argumentTypes); if (constructor != null) { return (Tool) constructor.Invoke(arguments); } return null; }
public Tool GetTool(ToolType type) { Tool result; _tools.TryGetValue(type, out result); if (result == null) { result = _factory.GetTool(type, new object[]{_viewModel}); _tools[type] = result; } return result; }
// ToolType - The type of tool that is trying to activate this switch public void Trigger(ToolType type) { Debug.Log("Trigger called by tool type: " + type); if (m_Activatable.Length == 0) { Debug.LogWarning("Triggered a switch with no Activatables attached"); } for (int idx = 0; idx < m_Activatable.Length; ++idx) { m_Activatable[idx].Activate(); } }
public static void ActivateTool(ToolType toolType) { _gameData.ActiveTool = toolType; if (toolType != ToolType.SuperJump) { _gameData.ToolCounts[(int)toolType] -= 1; } switch (toolType) { case ToolType.Invincibility: _gameData.ActiveToolTimeRemaining = Constants.Invincibility_Duration; break; case ToolType.Jetpack: _gameData.ActiveToolTimeRemaining = Constants.Jetpack_Duration; break; case ToolType.Pickaxe: _gameData.ActiveToolTimeRemaining = Constants.Pickaxe_Duration; break; case ToolType.FireExtinguisher: _gameData.ActiveToolTimeRemaining = Constants.Fire_Extinguisher_Duration; break; } }
/// <summary> Gets or sets the raw effectiveness of /// this tool for the specified tool type. </summary> public float this[ToolType type] { get { return ((Enum.IsDefined(typeof(ToolType), type) && (type != ToolType.None)) ? _toolEffectiveness[(int)type - 1] : 0.0F); } set { if ((value < 0.0F) || (value > 1.0F)) throw new ArgumentOutOfRangeException("value", value, "Effectiveness is not a valid value (0.0 to 1.0)"); if (!Enum.IsDefined(typeof(ToolType), type) || (type == ToolType.None)) throw new ArgumentException(string.Format( "'{0}' is not a valid ToolType", type), "type"); _toolEffectiveness[(int)type - 1] = value; } }
public void Refill(ToolType refillType, int refillCount) { switch (refillType) { case ToolType.Beacon: m_BeaconCount = refillCount; break; case ToolType.Magnet: break; case ToolType.Stunner: m_GrenadeCount = refillCount; break; } }
public static void SendActivateToolMessage(Player player, ToolSlot slot, ToolType type, bool newState, string propertyName, float propertyValue, byte id, bool immediate) { SendMessageHeader(MessageType.ActivateTool, id); Storage.PacketWriter.Write((byte)slot); Storage.PacketWriter.Write((byte)type); Storage.PacketWriter.Write(newState); Storage.PacketWriter.Write(propertyName ?? ""); Storage.PacketWriter.Write(propertyValue); if(immediate) { SendOneOffMessage(player); } }
// Update is called once per frame void Update () { // Plant if (GameManager.Instance.state == GameManager.GameState.Playing) { if (Input.GetButtonDown ("P2_A")) { switch (currentTool) { case ToolType.Candy: if (currentTile != null && currentTile.GetComponent<EdgeTile> ().GetIsInUse () == false) { currentTile.GetComponent<EdgeTile> ().SetIsInUse (true); if (tools[(int)currentTool] > 0) { currentTile.GetComponent<EdgeTile>().SetTrap(); StartCoroutine (Candy(0.25f)); tools[(int)currentTool]--; RenderTools (); } } break; case ToolType.Boot: if (tools[(int)currentTool] > 0) { foreach (GameObject ant in GameManager.Instance.antList) { ant.GetComponent<AntAI> ().Retreat (); } StartCoroutine (Stomp(0.4f)); tools[(int)currentTool]--; RenderTools (); } break; } } //Weapon Toggle if (Input.GetButtonDown ("P2_R1")) { int nextSeed = ((int)currentTool + 1); currentTool = nextSeed >= tools.Count ? 0 : (ToolType)nextSeed; RenderTools (); } else if (Input.GetButtonDown ("P2_L1")) { int nextSeed = ((int)currentTool - 1); currentTool = nextSeed < 0 ? (ToolType)(tools.Count-1) : (ToolType)nextSeed; RenderTools (); } } }