public AttributeModifier(string atributeAlias, float valueChange, ModifierType modifierType = ModifierType.Absolute, string name = null)
     : base(name)
 {
     this.AttributeAlias = atributeAlias;
     this.valueChange = valueChange;
     this.ChangeType = modifierType;
 }

    public void OnMouseButtonPress(Vector MousePos, int button, ModifierType Modifiers)
    {
        if (Tilemap == null) return;

        UpdateMouseTilePos(MousePos);

        if (button == 1) {
            if ((selection.Width == 1) && (selection.Height == 1)) {
                application.TakeUndoSnapshot("Fill Tool");
                FloodFill(MouseTilePos, selection[0, 0]);
            }
            LastDrawPos = MouseTilePos;
            drawing = true;
            Redraw();
        }
        if(button == 3) {
            if(MouseTilePos.X < 0 || MouseTilePos.Y < 0
                || MouseTilePos.X >= Tilemap.Width
                || MouseTilePos.Y >= Tilemap.Height)
                return;

            SelectStartPos = MouseTilePos;
            selecting = true;
            UpdateSelection();
            Redraw();
        }
    }

 private int GetModifierValue (ModifierTarget player, ModifierType modifierType)
 {
     ModifierTarget[] correctTargets = { player, ModifierTarget.All };
     return Modifiers.Where (
         i => correctTargets.Contains (i.Target) &&
         i.Modifier == modifierType).Sum (i => i.Value);
 }

    public void OnMouseButtonRelease(Vector MousePos, int button, ModifierType Modifiers)
    {
        if (Tilemap == null) return;

        UpdateMouseTilePos(MousePos);

        if(button == 1) {
            drawing = false;
        }
        if(button == 3) {
            UpdateSelection();

            uint NewWidth = (uint) (SelectionP2.X - SelectionP1.X) + 1;
            uint NewHeight = (uint) (SelectionP2.Y - SelectionP1.Y) + 1;
            selection.Resize(NewWidth, NewHeight, 0);
            for(uint y = 0; y < NewHeight; y++) {
                for(uint x = 0; x < NewWidth; ++x) {
                    selection[x, y]
                        = Tilemap[(uint) SelectionP1.X + x,
                                  (uint) SelectionP1.Y + y];
                }
            }

            selection.FireChangedEvent();
            selecting = false;
        }

        Redraw();
    }

        public void AddAction(string playerA, string playerB, ActionType actionType, ModifierType modifyer, Weapon weapon, WhereType where, ArmyType teamA, ArmyType teamB)
        {
            Player playerGet = getPlayer(playerA, teamA);
            Player playerDo = null;
            
            //damage from the world (harrier, falling) will not be considered in this version
            if (playerB == string.Empty)
            {
                playerDo = playerGet;
            } else
            {
                playerDo = getPlayer(playerB, teamB);
            }

            switch (actionType)
            {
                case ActionType.Kill:
                    playerGet.AddAction(playerDo, ActionType.Die, modifyer, weapon, where);
                    playerDo.AddAction(playerGet, ActionType.Kill, modifyer, weapon, where);
                    break;
                case ActionType.Damage:
                    playerGet.AddAction(playerDo, ActionType.Damage, modifyer, weapon, where);
                    playerDo.AddAction(playerGet, ActionType.Damage, modifyer, weapon, where);
                    break;
            }
        }

 /// <summary>
 /// Returns unit to snap to, based on passed Modifier keys and application settings
 /// </summary>
 protected int SnapValue(ModifierType Modifiers)
 {
     if ((Modifiers & ModifierType.ShiftMask) != 0) return 32;
     if ((Modifiers & ModifierType.ControlMask) != 0) return 16;
     if (application.SnapToGrid) return 32;
     return 0;
 }

 public Mod(StatType stat, ModifierType type, double value)
     : this()
 {
     Stat = stat;
     Type = type;
     Value = value;
 }

 public bool KeyPress(Key key, char keyChar, ModifierType modifier)
 {
     int indentLength;
     char bulletChar;
     if(key == Key.Return)
     {
         var bulletState = GetBulletState(document.Editor.Caret.Line, out indentLength, out bulletChar);
         if(bulletState == BulletState.None)
         {
             return true;
         }
         if(bulletState == BulletState.InBullet)
         {
             // I'm not sure why the last space is eaten here
             var bulletLine = new string(' ', indentLength) + bulletChar + "  ";
             // + 1 since we put it at the next line
             document.Editor.Insert(document.Editor.Caret.Offset + 1, bulletLine);
             document.Editor.Caret.Offset += bulletLine.Length;
             document.Editor.Insert(document.Editor.Caret.Offset, document.Editor.EolMarker);
             document.Editor.Caret.Offset--;
             return false;
         }
         // time to finish the bullet
         var currentLine = document.Editor.GetLine(document.Editor.Caret.Line);
         document.Editor.Remove(currentLine.Offset, currentLine.Length);
         return true;
     }
     return true;
 }

 public static StatModifier Of (ModifierType modifier, ModifierTarget target, int value)
 {
     return new StatModifier {
         Modifier = modifier,
         Target = target,
         Value = value
     };
 }

		public void ProcessKey (Key key, char ch, ModifierType modifiers)
		{
			var k = ch == '\0'? new ViKey (modifiers, key) : new ViKey (modifiers, ch);
			Keys.Add (k);
			if (!Builder (this)) {
				SetError ("Unknown command");
			}
		}

		public void Build (ViEditor editor, Key key, char ch, ModifierType modifiers)
		{
			var k = ch == '\0'? new ViKey (modifiers, key) : new ViKey (modifiers, ch);
			Keys.Add (k);
			if (!Builder (this)) {
				Error = "Unknown command";
			}
		}

    public void OnMouseButtonPress(Vector pos, int button, ModifierType Modifiers)
    {
        application.TakeUndoSnapshot( "Created Object '" + objectType + "'" );
        IGameObject gameObject = CreateObjectAt(pos);

        // switch back to object edit mode when shift was not pressed
        if((Modifiers & ModifierType.ShiftMask) == 0) {
            ObjectsEditor editor = new ObjectsEditor(application, application.CurrentSector);
            if(gameObject is IObject) {
                editor.MakeActive((IObject) gameObject);
            }
            application.SetEditor(editor);
        }
    }

        /// <summary>
        /// Breaks apart an event key into the individual and normalized key and
        /// any modifiers.
        /// </summary>
        /// <param name="evt">The evt.</param>
        /// <param name="key">The key.</param>
        /// <param name="modifiers">The mod.</param>
        public static void DecomposeKeys(
			EventKey evt,
			out Key key,
			out ModifierType modifiers)
        {
            // Use the keymap to decompose various elements of the hardware keys.
            uint keyval;
            int effectiveGroup,
                level;
            ModifierType consumedModifiers;

            keymap.TranslateKeyboardState(
                evt.HardwareKeycode,
                evt.State,
                evt.Group,
                out keyval,
                out effectiveGroup,
                out level,
                out consumedModifiers);

            // Break out the identified keys and modifiers.
            key = (Key) keyval;
            modifiers = evt.State & ~consumedModifiers;

            // Normalize some of the keys that don't make sense.
            if (key == Key.ISO_Left_Tab)
            {
                key = Key.Tab;
                modifiers |= ModifierType.ShiftMask;
            }

            // Check to see if we are a character and pull out the shift key if
            // it is a capital letter. This is used to normalize so all the
            // keys are uppercase with a shift modifier.
            bool shiftWasConsumed = ((evt.State ^ modifiers) & ModifierType.ShiftMask)
                != 0;
            var unicode = (char) Keyval.ToUnicode((uint) key);

            if (shiftWasConsumed && Char.IsUpper(unicode))
            {
                modifiers |= ModifierType.ShiftMask;
            }

            if (Char.IsLetter(unicode)
                && Char.IsLower(unicode))
            {
                key = (Key) Char.ToUpper(unicode);
            }
        }

		public override bool KeyPress (Key key, char keyChar, ModifierType modifier)
		{
			var result = base.KeyPress (key, keyChar, modifier);

			if (key == Key.Return) {
				if (textEditorData.Options.IndentStyle == IndentStyle.Virtual) {
					if (textEditorData.GetLine (textEditorData.Caret.Line).Length == 0)
						textEditorData.Caret.Column = textEditorData.IndentationTracker.GetVirtualIndentationColumn (textEditorData.Caret.Location);
				} else {
					DoReSmartIndent ();
				}
			}

			return result;
		}

		/// <summary>
		/// Adds a given value to the existing value for a specific <see cref="ModifierType" /> in a
		/// specific <see cref="ModifierCategory">collection</see>. 
		/// </summary>
		/// <param name="collectionType">the collection type</param>
		/// <param name="statType">the stat type</param>
		/// <param name="value">the amount to add</param>
		public void AddToStat(ModifierCategory collectionType, ModifierType statType, double value)
		{
			m_changeLock.EnterWriteLock();

			try
			{
				m_modifiers[collectionType][statType] += value;

				if (!IsChangeFlagged(statType))
				{
					m_changes.AddLast(statType);
				}
			}
			finally
			{
				m_changeLock.ExitWriteLock();
			}
		}

		protected override void OnScrolled (ScrollDirection direction, ModifierType mod)
		{
			if ((mod & ModifierType.ShiftMask) != ModifierType.ShiftMask)
				return;
			
			int shift = HueShift;
			
			if (direction == Gdk.ScrollDirection.Up)
				shift += 5;
			else if (direction == Gdk.ScrollDirection.Down)
				shift -= 5;
			
			if (shift < 0)
				shift += 360;
			shift %= 360;
			
			HueShift = shift;
		}

    public void OnMouseButtonPress(Vector mousePos, int button, ModifierType Modifiers)
    {
        if (button == 1){
            IGameObject gameObject = CreateObjectAt(MousePos);

            // switch back to object edit mode when shift was not pressed
            if((Modifiers & ModifierType.ShiftMask) == 0) {
                ObjectSelectTool editor = new ObjectSelectTool(application, application.CurrentSector);
                if(gameObject is IObject) {
                    editor.MakeActive((IObject) gameObject);
                }
                application.SetTool(editor);
            }
        } else {	//cancel creation by other buttons
            application.SetToolObjects();
        }
        if (UpdateMousePos(mousePos))
            Redraw();
    }

    void SetSecondaryWeaponModifier(ModifierType modifierType)
    {
        if ( modifierType == ModifierType.None)
            return;

        if ( modifierType < ModifierType.NUM_ELEMENTAL_MODIFIERS ) { // ElementalModifier
            // update the elemental modifier
            switch(modifierType) {
                case ModifierType.Poison : modifierCombo.setElemental("PoisonModifier"); modifierDisplay.setEMod("Poison"); break;
                case ModifierType.EMP : modifierCombo.setElemental("EMPModifier"); modifierDisplay.setEMod("EMP"); break;
                case ModifierType.Explosion : modifierCombo.setElemental("ExplosionModifier"); modifierDisplay.setEMod("Explosion"); break;
                }
            }
        else { // BehavioralModifier
            // update the behavioral modifier
            switch(modifierType) {
                case ModifierType.HeatSeek : modifierCombo.setBehavioral("HeatSeekModifier"); modifierDisplay.setBMod("HeatSeek"); break;
                case ModifierType.Spread : modifierCombo.setBehavioral("SpreadModifier"); modifierDisplay.setBMod("Spread"); break;
                case ModifierType.Rebound : modifierCombo.setBehavioral("RebounderModifier"); modifierDisplay.setBMod("Rebound"); break;
            }
        }
        GetComponent<SecondaryFiring> ().SetEnergyCost (modifierCombo);
    }

 public new void OnMouseMotion(Vector mousePos, ModifierType Modifiers)
 {
     if (UpdateMouseTilePos(mousePos)) {
         if (state == State.DRAWING) {
             if (LastDrawPos != MouseTilePos) {
                 LastDrawPos = MouseTilePos;
                 brush.ApplyToTilemap(MouseTilePos, application.CurrentTilemap);
             }
         }
         if (state == State.FILLING || state == State.SELECTING) {
             UpdateSelection();
         }
         FireRedraw();
     }
 }

 /// <summary>
 /// Checks if a change is flagged in the collection.
 /// </summary>
 /// <param name="statType">the stat type</param>
 /// <returns>true if the stat type is flagged; false otherwise</returns>
 private bool IsChangeFlagged(ModifierType statType)
 {
     return m_changes.Where(statChange => statChange == statType).Any();
 }