context: #region Copyright & License Information
  /*
   * Copyright 2007-2020 The OpenRA Developers (see AUTHORS)
   * This file is part of OpenRA, which is free software. It is made
   * available to you under the terms of the GNU General Public License
   * as published by the Free Software Foundation, either version 3 of
   * the License, or (at your option) any later version. For more
   * information, see COPYING.
   */
  #endregion
  
  using System;
  using System.Collections.Generic;
  using OpenRA.Activities;
  using OpenRA.Graphics;
  using OpenRA.Mods.Common.Activities;
  using OpenRA.Mods.Common.Graphics;
  using OpenRA.Primitives;
  using OpenRA.Traits;
  
  namespace OpenRA.Mods.Common.Traits
  {
  	public enum VisibilityType { Footprint, CenterPosition, GroundPosition }
  
  	public enum AttackDelayType { Preparation, Attack }
  
  	[Flags]
  	public enum ResupplyType
  	{
  		None = 0,
  		Rearm = 1,
  		Repair = 2
  	}
  
  	public interface IQuantizeBodyOrientationInfo : ITraitInfoInterface
  	{
  		int QuantizedBodyFacings(ActorInfo ai, SequenceProvider sequenceProvider, string race);
  	}
  
  	public interface IPlaceBuildingDecorationInfo : ITraitInfoInterface
  	{
  		IEnumerable<IRenderable> RenderAnnotations(WorldRenderer wr, World w, ActorInfo ai, WPos centerPosition);
  	}
  
  	[RequireExplicitImplementation]
  	public interface IBlocksProjectiles
  	{
  		WDist BlockingHeight { get; }
  	}
  
  	[RequireExplicitImplementation]
  	public interface IBlocksProjectilesInfo : ITraitInfoInterface { }
  
  	[RequireExplicitImplementation]
  	public interface INotifySold
  	{
  		void Selling(Actor self);
  		void Sold(Actor self);
  	}
  
  	[RequireExplicitImplementation]
  	public interface INotifyCustomLayerChanged
  	{
  		void CustomLayerChanged(Actor self, byte oldLayer, byte newLayer);
  	}
  
  	[RequireExplicitImplementation]
  	public interface INotifyVisualPositionChanged
  	{
  		void VisualPositionChanged(Actor self, byte oldLayer, byte newLayer);
  	}
  
  	[RequireExplicitImplementation]
  	public interface INotifyFinishedMoving
  	{
  		void FinishedMoving(Actor self, byte oldLayer, byte newLayer);
  	}
  
  	public interface IDemolishableInfo : ITraitInfoInterface { bool IsValidTarget(ActorInfo actorInfo, Actor saboteur); }
  	public interface IDemolishable
  	{
  		bool IsValidTarget(Actor self, Actor saboteur);
  		void Demolish(Actor self, Actor saboteur, int delay, BitSet<DamageType> damageTypes);
  	}
  
  	// Type tag for crush class bits
  	public class CrushClass { }
  
  	[RequireExplicitImplementation]
  	public interface ICrushable
  	{
  		bool CrushableBy(Actor self, Actor crusher, BitSet<CrushClass> crushClasses);
  		LongBitSet<PlayerBitMask> CrushableBy(Actor self, BitSet<CrushClass> crushClasses);
  	}
  
  	[RequireExplicitImplementation]
  	public interface INotifyCrushed
  	{
  		void OnCrush(Actor self, Actor crusher, BitSet<CrushClass> crushClasses);
  		void WarnCrush(Actor self, Actor crusher, BitSet<CrushClass> crushClasses);
  	}
  
  	[RequireExplicitImplementation]
  	public interface INotifyAiming
  	{
  		void StartedAiming(Actor self, AttackBase attack);
  		void StoppedAiming(Actor self, AttackBase attack);
  	}
  
  	[RequireExplicitImplementation]
  	public interface INotifyAttack
  	{
  		void Attacking(Actor self, Target target, Armament a, Barrel barrel);
  		void PreparingAttack(Actor self, Target target, Armament a, Barrel barrel);
  	}
  
  	[RequireExplicitImplementation]
  	public interface INotifyDamageStateChanged { void DamageStateChanged(Actor self, AttackInfo e); }
  
  	[RequireExplicitImplementation]
  	public interface INotifyDamage { void Damaged(Actor self, AttackInfo e); }
  	[RequireExplicitImplementation]
  	public interface INotifyKilled { void Killed(Actor self, AttackInfo e); }
  	[RequireExplicitImplementation]
  	public interface INotifyAppliedDamage { void AppliedDamage(Actor self, Actor damaged, AttackInfo e); }
  
  	[RequireExplicitImplementation]
  	public interface INotifyResupply
  	{
  		void BeforeResupply(Actor host, Actor target, ResupplyType types);
  		void ResupplyTick(Actor host, Actor target, ResupplyType types);
  	}
  
  	[RequireExplicitImplementation]
  	public interface INotifyBeingResupplied
  	{
  		void StartingResupply(Actor self, Actor host);
  		void StoppingResupply(Actor self, Actor host);
  	}
  
  	[RequireExplicitImplementation]
  	public interface INotifyPowerLevelChanged { void PowerLevelChanged(Actor self); }
  	public interface INotifySupportPower { void Charged(Actor self); void Activated(Actor self); }
  
  	public interface INotifyBuildingPlaced { void BuildingPlaced(Actor self); }
  	public interface INotifyBurstComplete { void FiredBurst(Actor self, Target target, Armament a); }
  	public interface INotifyChat { bool OnChat(string from, string message); }
  	public interface INotifyProduction { void UnitProduced(Actor self, Actor other, CPos exit); }
  	public interface INotifyOtherProduction { void UnitProducedByOther(Actor self, Actor producer, Actor produced, string productionType, TypeDictionary init); }
  	public interface INotifyDelivery { void IncomingDelivery(Actor self); void Delivered(Actor self); }
  	public interface INotifyDocking { void Docked(Actor self, Actor harvester); void Undocked(Actor self, Actor harvester); }
  
  	[RequireExplicitImplementation]
  	public interface INotifyResourceAccepted { void OnResourceAccepted(Actor self, Actor refinery, int amount); }
  	public interface INotifyParachute { void OnParachute(Actor self); void OnLanded(Actor self); }
  
  	[RequireExplicitImplementation]
  	public interface INotifyCapture { void OnCapture(Actor self, Actor captor, Player oldOwner, Player newOwner, BitSet<CaptureType> captureTypes); }
  	public interface INotifyDiscovered { void OnDiscovered(Actor self, Player discoverer, bool playNotification); }
  	public interface IRenderActorPreviewInfo : ITraitInfoInterface { IEnumerable<IActorPreview> RenderPreview(ActorPreviewInitializer init); }
  	public interface ICruiseAltitudeInfo : ITraitInfoInterface { WDist GetCruiseAltitude(); }
  
  	public interface IHuskModifier { string HuskActor(Actor self); }
  
  	public interface ISeedableResource { void Seed(Actor self); }
  
  	[RequireExplicitImplementation]
  	public interface INotifyInfiltrated { void Infiltrated(Actor self, Actor infiltrator, BitSet<TargetableType> types); }
  
  	[RequireExplicitImplementation]
  	public interface INotifyBlockingMove { void OnNotifyBlockingMove(Actor self, Actor blocking); }
  
  	[RequireExplicitImplementation]
  	public interface INotifyPassengerEntered { void OnPassengerEntered(Actor self, Actor passenger); }
  
  	[RequireExplicitImplementation]
  	public interface INotifyPassengerExited { void OnPassengerExited(Actor self, Actor passenger); }
  
  	[RequireExplicitImplementation]
  	public interface INotifyEnteredCargo { void OnEnteredCargo(Actor self, Actor cargo); }
  
  	[RequireExplicitImplementation]
  	public interface INotifyExitedCargo { void OnExitedCargo(Actor self, Actor cargo); }
  
  	public interface INotifyHarvesterAction
  	{
  		void MovingToResources(Actor self, CPos targetCell);
  		void MovingToRefinery(Actor self, Actor refineryActor);
  		void MovementCancelled(Actor self);
  		void Harvested(Actor self, ResourceType resource);
  		void Docked();
  		void Undocked();
  	}
  
  	[RequireExplicitImplementation]
  	public interface INotifyUnload
  	{
  		void Unloading(Actor self);
  	}
  
  	[RequireExplicitImplementation]
  	public interface INotifyDemolition
  	{
  		void Demolishing(Actor self);
  	}
  
  	[RequireExplicitImplementation]
  	public interface INotifyInfiltration
  	{
  		void Infiltrating(Actor self);
  	}
  
  	public interface ITechTreePrerequisiteInfo : ITraitInfoInterface
  	{
  		IEnumerable<string> Prerequisites(ActorInfo info);
  	}
  
  	public interface ITechTreePrerequisite
  	{
  		IEnumerable<string> ProvidesPrerequisites { get; }
  	}
  
  	public interface ITechTreeElement
  	{
  		void PrerequisitesAvailable(string key);
  		void PrerequisitesUnavailable(string key);
  		void PrerequisitesItemHidden(string key);
  		void PrerequisitesItemVisible(string key);
  	}
  
  	public interface IProductionIconOverlay
  	{
  		Sprite Sprite { get; }
  		string Palette { get; }
  		float2 Offset(float2 iconSize);
  		bool IsOverlayActive(ActorInfo ai);
  	}
  
  	public interface INotifyTransform
  	{
  		void BeforeTransform(Actor self);
  		void OnTransform(Actor self);
  		void AfterTransform(Actor toActor);
  	}
  
  	public interface INotifyDeployComplete
  	{
  		void FinishedDeploy(Actor self);
  		void FinishedUndeploy(Actor self);
  	}
  
  	public interface INotifyDeployTriggered
  	{
  		void Deploy(Actor self, bool skipMakeAnim);
  		void Undeploy(Actor self, bool skipMakeAnim);
  	}
  
  	public interface IAcceptResourcesInfo : ITraitInfoInterface { }
  	public interface IAcceptResources
  	{
  		void OnDock(Actor harv, DeliverResources dockOrder);
  		void GiveResource(int amount);
  
gt: 		bool CanGiveResource(int amount);