public Fatter(Vector3 position,
ComponentManager componentManager,
ContentManager content,
GraphicsDevice graphics)
: base("Fatter", position, componentManager, content, graphics, "fatwalk")
{
}
public Mesh(ComponentManager manager, string name, GameComponent parent, Matrix localTransform, string modelType, bool addToCollisionManager)
: base(name, parent, localTransform, Vector3.Zero, Vector3.Zero, addToCollisionManager)
{
ModelType = modelType;
Instance = PlayState.InstanceManager.AddInstance(ModelType, GlobalTransform, Tint);
instanceVisible = true;
}
public Deer(string sprites, Vector3 position, ComponentManager manager, ChunkManager chunks, GraphicsDevice graphics, ContentManager content, string name)
: base(new CreatureStats
{
Dexterity = 12,
Constitution = 6,
Strength = 3,
Wisdom = 2,
Charisma = 1,
Intelligence = 3,
Size = 3
},
"Herbivore",
PlayState.PlanService,
manager.Factions.Factions["Herbivore"],
new Physics
(
"A Deer",
manager.RootComponent,
Matrix.CreateTranslation(position),
new Vector3(0.3f, 0.3f, 0.3f),
new Vector3(0, 0, 0),
1.0f, 1.0f, 0.999f, 0.999f,
new Vector3(0, -10, 0)
),
chunks, graphics, content, name)
{
Initialize(new SpriteSheet(sprites));
}
public Smoker(Vector3 position,
ComponentManager componentManager,
ContentManager content,
GraphicsDevice graphics)
: base("Smoker", position, componentManager, content, graphics, "smokewalk")
{
}
public Older(Vector3 position,
ComponentManager componentManager,
ContentManager content,
GraphicsDevice graphics)
: base("Older", position, componentManager, content, graphics, "oldwalk")
{
}
public Router()
{
appDomains = new ConcurrentDictionary<string, ComponentManager>();
componentPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
componentManager = new ComponentManager();
logger = new MuleLogger(Log);
}
public TrapSensor(ComponentManager manager, string name, GameComponent parent, Matrix localTransform, Vector3 boundingBoxExtents, Vector3 boundingBoxPos)
: base(name, parent, localTransform, boundingBoxExtents, boundingBoxPos)
{
OnSensed += TrapSensor_OnSensed;
Tags.Add("Sensor");
DrawBoundingBox = true;
FireTimer = new Timer(0.5f, false);
}
public VoxelListener(ComponentManager manager, GameComponent parent, ChunkManager chunkManager, Voxel vref)
: base("VoxelListener", parent)
{
Chunk = vref.Chunk;
VoxelID = new Point3(vref.GridPosition);
Chunk.OnVoxelDestroyed += VoxelListener_OnVoxelDestroyed;
ChunkID = Chunk.ID;
}
public GameMaster(Faction faction, DwarfGame game, ComponentManager components, ChunkManager chunks, Camera camera, GraphicsDevice graphics, DwarfGUI gui)
{
Faction = faction;
Initialize(game, components, chunks, camera, graphics, gui);
VoxSelector.Selected += OnSelected;
BodySelector.Selected += OnBodiesSelected;
PlayState.Time.NewDay += Time_NewDay;
}
public TintableComponent(ComponentManager manager, string name, GameComponent parent, Matrix localTransform, Vector3 boundingBoxExtents, Vector3 boundingBoxPos, bool octree)
: base(manager, name, parent, localTransform, boundingBoxExtents, boundingBoxPos, octree)
{
Tint = Color.White;
LightingTimer = new Timer(1.0f, false);
TargetTint = Tint;
TintChangeRate = 1.0f;
}
public Sprite(ComponentManager manager, string name, GameComponent parent, Matrix localTransform, SpriteSheet spriteSheet, bool addToCollisionManager)
: base(name, parent, localTransform, Vector3.Zero, Vector3.Zero, addToCollisionManager)
{
SpriteSheet = spriteSheet;
Animations = new Dictionary<string, Animation>();
OrientationType = OrientMode.Spherical;
BillboardRotation = 0.0f;
}
public Health(ComponentManager manager, string name, GameComponent parent, float maxHealth, float minHealth, float currentHp)
: base(name, parent)
{
InitializeResistance();
MaxHealth = maxHealth;
MinHealth = minHealth;
Hp = currentHp;
}
public BillboardSpriteComponent(ComponentManager manager, string name, GameComponent parent, Matrix localTransform, Texture2D spriteSheet, bool addToOctree)
: base(manager, name, parent, localTransform, Vector3.Zero, Vector3.Zero, addToOctree)
{
SpriteSheet = spriteSheet;
Animations = new Dictionary<string, Animation> ();
OrientsToCamera = true;
BillboardRotation = 0.0f;
Offset = Vector3.Zero;
}
/// <summary>
/// Constructor
/// </summary>
public GameObjectCollection()
{
GameObjects = new List<GameObject>( DEFAULT_CAPACITY );
AiControllers = new ComponentManager<AiController>( DEFAULT_CAPACITY );
ActorControllers = new ComponentManager<ActorController>( DEFAULT_CAPACITY );
Movements = new ComponentManager<MovementComponent>( DEFAULT_CAPACITY );
Sprites = new ComponentManager<SpriteComponent>( DEFAULT_CAPACITY );
mIdManager = new UniqueIdManager();
}
public EnemySensor(ComponentManager manager, string name, GameComponent parent, Matrix localTransform, Vector3 boundingBoxExtents, Vector3 boundingBoxPos)
: base(name, parent, localTransform, boundingBoxExtents, boundingBoxPos)
{
Enemies = new List<CreatureAI>();
OnEnemySensed += EnemySensor_OnEnemySensed;
Tags.Add("Sensor");
SenseTimer = new Timer(0.5f, false);
SenseRadius = 15 * 15;
}
public ShadowComponent(ComponentManager manager, string name, GameComponent parent, Matrix localTransform, Texture2D spriteSheet)
: base(manager, name, parent, localTransform, spriteSheet, false)
{
OrientsToCamera = false;
GlobalScale = 1.0f;
DrawBoundingBox = false;
UpdateTimer = new Timer(0.5f,false);
Tint = Color.White;
Height = 0.1f;
}
public EmitterComponent(ParticleManager particles, string emitter, ComponentManager manager, string name, GameComponent parent, Matrix localTransform, Vector3 boundingBoxExtents, Vector3 boundingBoxPos)
: base(manager, name, parent, localTransform, boundingBoxExtents, boundingBoxPos, false)
{
ParticleManager = particles;
Emitter = emitter;
TriggerOnDeath = true;
TriggerAmount = 10;
BoxTriggerTimes = 10;
TriggerInBox = true;
}
public Shadow(ComponentManager manager, string name, GameComponent parent, Matrix localTransform, SpriteSheet spriteSheet)
: base(manager, name, parent, localTransform, spriteSheet, false)
{
OrientationType = OrientMode.Fixed;
GlobalScale = LocalTransform.Left.Length();
LightsWithVoxels = false;
UpdateTimer = new Timer(0.5f, false);
Tint = Color.Black;
OriginalTransform = LocalTransform;
}
public ParticleTrigger(string emitter, ComponentManager manager, string name, GameComponent parent, Matrix localTransform, Vector3 boundingBoxExtents, Vector3 boundingBoxPos)
: base(name, parent, localTransform, boundingBoxExtents, boundingBoxPos, false)
{
SoundToPlay = ContentPaths.Audio.explode;
EmitterName = emitter;
TriggerOnDeath = true;
TriggerAmount = 2;
BoxTriggerTimes = 10;
TriggerInBox = true;
}
public Flammable(ComponentManager manager, string name, Body parent, Health health)
: base(name, parent)
{
LocParent = parent;
Heat = 0.0f;
Flashpoint = 100.0f;
Damage = 50.0f;
Health = health;
CheckLavaTimer = new Timer(1.0f, false);
SoundTimer = new Timer(1.0f, false);
DamageTimer = new Timer(1.0f, false);
}
public static void Init(ComponentManager cm)
{
ComponentManager = cm;
if(Platform.IsWindows)
{
PIXBUF_INFO = SystemDrawing_vs_GTK_Conversion.Bitmap2Pixbuf(System.Drawing.SystemIcons.Information);
PIXBUF_WARNING = SystemDrawing_vs_GTK_Conversion.Bitmap2Pixbuf(System.Drawing.SystemIcons.Warning);
PIXBUF_QUESTION = SystemDrawing_vs_GTK_Conversion.Bitmap2Pixbuf(System.Drawing.SystemIcons.Question);
PIXBUF_ERROR = SystemDrawing_vs_GTK_Conversion.Bitmap2Pixbuf(System.Drawing.SystemIcons.Error);
}
}
public BillboardList(ComponentManager manager,
string name,
GameComponent parent,
Matrix localTransform,
Texture2D spriteSheet,
int numBillboards)
: base(manager, name, parent, localTransform, spriteSheet, false)
{
LocalTransforms = new List<Matrix>(numBillboards);
Rotations = new List<float>(numBillboards);
Tints = new List<Color>(numBillboards);
FrustrumCull = false;
}
public LocatableComponent(ComponentManager manager, string name, GameComponent parent, Matrix localTransform, Vector3 boundingBoxExtents, Vector3 boundingBoxPos, bool addToOctree)
: base(manager, name, parent)
{
AddToOctree = addToOctree;
BoundingBoxPos = boundingBoxPos;
DrawBoundingBox = false;
BoundingBox = new BoundingBox(localTransform.Translation - boundingBoxExtents / 2.0f + boundingBoxPos, localTransform.Translation + boundingBoxExtents / 2.0f + boundingBoxPos);
LocalTransform = localTransform;
HasMoved = true;
DepthSort = true;
FrustrumCull = true;
DrawInFrontOfSiblings = false;
IsStocked = false;
}
public BatchBillboard(ComponentManager manager,
string name,
GameComponent parent,
Matrix localTransform,
Texture2D spriteSheet,
int numBillboards, GraphicsDevice graphi)
: base(manager, name, parent, localTransform, spriteSheet, false)
{
LocalTransforms = new List<Matrix>(numBillboards);
Rotations = new List<float>(numBillboards);
Tints = new List<Color>(numBillboards);
FrustrumCull = false;
Width = spriteSheet.Width;
Height = spriteSheet.Height;
Frame = new Point(0, 0);
graphicsDevice = graphi;
}
public PhysicsComponent(ComponentManager manager, string name, GameComponent parent, Matrix localTransform,
Vector3 boundingBoxExtents, Vector3 boundingBoxPos, float mass, float i, float linearDamping, float angularDamping)
: base(manager, name, parent, localTransform, boundingBoxExtents, boundingBoxPos)
{
Mass = mass;
Velocity = Vector3.Zero;
AngularVelocity = Vector3.Zero;
I = i;
LinearDamping = linearDamping;
AngularDamping = angularDamping;
Gravity = new Vector3(0, -20, 0);
Restitution = 0.99f;
Friction = 0.99f;
OrientWithVelocity = false;
IsSleeping = false;
PreviousPosition = LocalTransform.Translation;
}
/// <summary>
/// コンストラクタ
/// </summary>
public Layer2D()
{
coreLayer2D = Engine.ObjectSystemFactory.CreateLayer2D();
var p = coreLayer2D.GetPtr();
if(GC.Layer2Ds.GetObject(p) != null)
{
Particular.Helper.ThrowException("");
}
GC.Layer2Ds.AddObject(p, this);
contentsManager = new ContentsManager<Object2D>();
componentManager = new ComponentManager<Layer2D, Layer2DComponent>(this);
commonObject = coreLayer2D;
}
public override void Load()
{
base.Load();
// setting general plugin globals
m_statTracker = m_core.GetStatTracker();
m_guinan = m_core.GetGuinan();
m_d3d = m_core.GetD3D();
m_componentManager = GlobalVariables.componentManager;
m_mainForm = m_core.GetMainForm();
m_tray = m_core.GetTrayIcon();
// specific globals
m_directoryLocation = "CustomAchievements";
List<ImageFile> ImageFileList = FindImageFilenames();
SetAchievementImages(ImageFileList);
}
public Hospital(Vector3 position, Vector3 size, ComponentManager componentManager,
ContentManager content,
GraphicsDevice graphics,
string name, Color color, Point side)
{
Color = color;
Score = 0.0f;
Component = EntityFactory.GenerateBuilding(position, size, componentManager, content, graphics, name, side);
/*
Vector3 invisOffset = new Vector3(0, size.Y, 0);
Vector3 invisSize = new Vector3(size.X, size.Y * 4, size.Z);
InvisibleBox = EntityFactory.GenerateBuilding(position + invisOffset, invisSize, componentManager, content, graphics, name, side);
InvisibleBox.SetVisibleRecursive(false);
*/
NumPatients = 0;
}
// Creature base constructor
public Bird(string sprites, Vector3 position, ComponentManager manager, ChunkManager chunks, GraphicsDevice graphics, ContentManager content, string name)
: base(// Default stats
new CreatureStats
{
Dexterity = 6,
Constitution = 1,
Strength = 1,
Wisdom = 1,
Charisma = 1,
Intelligence = 1,
Size = 0.25f,
CanSleep = false
},
// Belongs to herbivore team
"Herbivore",
// Uses the default plan service
PlayState.PlanService,
// Belongs to the herbivore team
manager.Factions.Factions["Herbivore"],
// The physics component this creature belongs to
new Physics
(
// It is called "bird"
"A Bird",
// It's attached to the root component of the component manager
manager.RootComponent,
// It is located at a position passed in as an argument
Matrix.CreateTranslation(position),
// It has a size of 0.25 blocks
new Vector3(0.25f, 0.25f, 0.25f),
// Its bounding box is located in its center
new Vector3(0.0f, 0.0f, 0.0f),
//It has a mass of 1, a moment of intertia of 1, and very small friction/restitution
1.0f, 1.0f, 0.999f, 0.999f,
// It has a gravity of 10 blocks per second downward
new Vector3(0, -10, 0)
),
// All the rest of the arguments are passed in directly
chunks, graphics, content, name)
{
// Called from constructor with appropriate sprite asset as a string
Initialize(new SpriteSheet(sprites));
}
public Snake(string sprites, Vector3 position, ComponentManager manager, ChunkManager chunks, GraphicsDevice graphics, ContentManager content, string name)
: base(new CreatureStats
{
Dexterity = 12,
Constitution = 6,
Strength = 3,
Wisdom = 2,
Charisma = 1,
Intelligence = 3,
Size = 3
},
"Herbivore",
PlayState.PlanService,
manager.Factions.Factions["Herbivore"],
new Physics
(
"snake",
manager.RootComponent,
Matrix.CreateTranslation(position),
new Vector3(1, .3f, .5f),
new Vector3(0, 0, 0),
1.0f, 1.0f, 0.999f, 0.999f,
new Vector3(0, -10, 0)
),
chunks, graphics, content, name)
{
Tail = new Physics[5];
for (int i = 0; i < 5; ++i)
{
Tail[i] = new Physics
(
"snaketail",
manager.RootComponent,
Matrix.CreateTranslation(position),
new Vector3(2, 1.5f, .7f),
new Vector3(0, 0, 0),
1.0f, 1.0f, 0.995f, 0.999f,
new Vector3(0, -10, 0)
);
}
Initialize(new SpriteSheet(sprites));
}
public static void OnInitialized(ComponentManager componentManager, ComponentChangeNotifier componentChangeNotifier)
{
WampRouterFacade.RegisterCallee(new ComponentsRpcService(componentManager));
WampRouterFacade.RegisterPublisher(new ComponentPublisher(componentChangeNotifier));
}
private void OnGasDualPortVentPumpUpdated(EntityUid uid, GasDualPortVentPumpComponent vent, AtmosDeviceUpdateEvent args)
{
var appearance = vent.Owner.GetComponentOrNull <AppearanceComponent>();
if (vent.Welded)
{
appearance?.SetData(VentPumpVisuals.State, VentPumpState.Welded);
return;
}
appearance?.SetData(VentPumpVisuals.State, VentPumpState.Off);
if (!vent.Enabled)
{
return;
}
if (!ComponentManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer))
{
return;
}
if (!nodeContainer.TryGetNode(vent.InletName, out PipeNode? inlet) ||
!nodeContainer.TryGetNode(vent.OutletName, out PipeNode? outlet))
{
return;
}
var environment = _atmosphereSystem.GetTileMixture(vent.Owner.Transform.Coordinates, true);
// We're in an air-blocked tile... Do nothing.
if (environment == null)
{
return;
}
if (vent.PumpDirection == VentPumpDirection.Releasing)
{
appearance?.SetData(VentPumpVisuals.State, VentPumpState.Out);
var pressureDelta = 10000f;
if ((vent.PressureChecks & DualPortVentPressureBound.ExternalBound) != 0)
{
pressureDelta = MathF.Min(pressureDelta, (vent.ExternalPressureBound - environment.Pressure));
}
if ((vent.PressureChecks & DualPortVentPressureBound.InputMinimum) != 0)
{
pressureDelta = MathF.Min(pressureDelta, (inlet.Air.Pressure - vent.InputPressureMin));
}
if (pressureDelta > 0 && inlet.Air.Temperature > 0)
{
var transferMoles = pressureDelta * environment.Volume / inlet.Air.Temperature * Atmospherics.R;
var removed = inlet.Air.Remove(transferMoles);
_atmosphereSystem.Merge(environment, removed);
}
}
else if (vent.PumpDirection == VentPumpDirection.Siphoning && environment.Pressure > 0f)
{
appearance?.SetData(VentPumpVisuals.State, VentPumpState.In);
var ourMultiplier = outlet.Air.Volume / environment.Temperature * Atmospherics.R;
var molesDelta = 10000 * ourMultiplier;
if ((vent.PressureChecks & DualPortVentPressureBound.ExternalBound) != 0)
{
molesDelta =
MathF.Min(molesDelta,
(environment.Pressure - vent.OutputPressureMax) * environment.Volume / (environment.Temperature * Atmospherics.R));
}
if ((vent.PressureChecks & DualPortVentPressureBound.InputMinimum) != 0)
{
molesDelta = MathF.Min(molesDelta, (vent.InputPressureMin - outlet.Air.Pressure) * ourMultiplier);
}
if (molesDelta > 0)
{
var removed = environment.Remove(molesDelta);
_atmosphereSystem.Merge(outlet.Air, removed);
}
}
}
//Update stats according to the history (if player died)
private void UpdateEntityStatsFromHistory(int entity)
{
ComponentManager cm = ComponentManager.GetInstance();
StatsComponent comp = cm.GetComponentForEntity <StatsComponent>(entity);
LevelComponent lvlComp = cm.GetComponentForEntity <LevelComponent>(entity);
while (comp.RemoveStats > 0)
{
if (lvlComp.CurrentLevel <= 0)
{
break;
}
if (comp.SpendableStats > 0)
{
comp.SpendableStats -= 1;
comp.RemoveStats -= 1;
}
else
{
if (comp.StatHistory.Length >= 3)
{
int start = comp.StatHistory.Length - 3;
string stat = comp.StatHistory.Substring(start);
switch (stat)
{
case "str":
if (cm.HasEntityComponent <AttackComponent>(entity) && cm.HasEntityComponent <HealthComponent>(entity))
{
AttackComponent attackComp = cm.GetComponentForEntity <AttackComponent>(entity);
HealthComponent healthComp = cm.GetComponentForEntity <HealthComponent>(entity);
attackComp.Damage = attackComp.Damage - 2;
healthComp.Max = healthComp.Max - 1;
healthComp.Current = healthComp.Current - 1;
comp.Strength -= 1;
}
break;
case "agi":
if (cm.HasEntityComponent <MoveComponent>(entity) && cm.HasEntityComponent <AttackComponent>(entity))
{
MoveComponent moveComp = cm.GetComponentForEntity <MoveComponent>(entity);
AttackComponent attackComp = cm.GetComponentForEntity <AttackComponent>(entity);
attackComp.RateOfFire = attackComp.RateOfFire - 0.05f;
moveComp.Speed = moveComp.Speed - 0.03f;
comp.Agility -= 1;
}
break;
case "sta":
if (cm.HasEntityComponent <HealthComponent>(entity))
{
HealthComponent healthComp = cm.GetComponentForEntity <HealthComponent>(entity);
healthComp.Max = healthComp.Max - 2;
healthComp.Current = healthComp.Current - 2;
comp.Stamina -= 1;
}
break;
case "int":
if (cm.HasEntityComponent <EnergyComponent>(entity))
{
EnergyComponent energyComp = cm.GetComponentForEntity <EnergyComponent>(entity);
energyComp.Max = energyComp.Max - 2;
comp.Intellect -= 1;
}
break;
}
comp.StatHistory = comp.StatHistory.Substring(0, comp.StatHistory.Length - 3);
comp.RemoveStats -= 1;
}
}
}
}
private void ConfigButtonClick(object sender, EventArgs e)
{
ComponentManager.ShowConfiguration();
}
/// <summary>
/// Constructs a MetadataView instance.
/// </summary>
public MetadataView()
{
this.metadata = ComponentManager.GetInterface <IScenarioManagerBC>().Metadata;
}
private void OnMixerUpdated(EntityUid uid, GasMixerComponent mixer, AtmosDeviceUpdateEvent args)
{
// TODO ATMOS: Cache total moles since it's expensive.
if (!mixer.Enabled)
{
return;
}
if (!ComponentManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer))
{
return;
}
if (!nodeContainer.TryGetNode(mixer.InletOneName, out PipeNode? inletOne) ||
!nodeContainer.TryGetNode(mixer.InletTwoName, out PipeNode? inletTwo) ||
!nodeContainer.TryGetNode(mixer.OutletName, out PipeNode? outlet))
{
return;
}
var outputStartingPressure = outlet.Air.Pressure;
if (outputStartingPressure >= mixer.TargetPressure)
{
return; // Target reached, no need to mix.
}
var generalTransfer = (mixer.TargetPressure - outputStartingPressure) * outlet.Air.Volume / Atmospherics.R;
var transferMolesOne = inletOne.Air.Temperature > 0 ? mixer.InletOneConcentration * generalTransfer / inletOne.Air.Temperature : 0f;
var transferMolesTwo = inletTwo.Air.Temperature > 0 ? mixer.InletTwoConcentration * generalTransfer / inletTwo.Air.Temperature : 0f;
if (mixer.InletTwoConcentration <= 0f)
{
if (inletOne.Air.Temperature <= 0f)
{
return;
}
transferMolesOne = MathF.Min(transferMolesOne, inletOne.Air.TotalMoles);
transferMolesTwo = 0f;
}
else if (mixer.InletOneConcentration <= 0)
{
if (inletTwo.Air.Temperature <= 0f)
{
return;
}
transferMolesOne = 0f;
transferMolesTwo = MathF.Min(transferMolesTwo, inletTwo.Air.TotalMoles);
}
else
{
if (inletOne.Air.Temperature <= 0f || inletTwo.Air.Temperature <= 0f)
{
return;
}
if (transferMolesOne <= 0 || transferMolesTwo <= 0)
{
return;
}
if (inletOne.Air.TotalMoles < transferMolesOne || inletTwo.Air.TotalMoles < transferMolesTwo)
{
var ratio = MathF.Min(inletOne.Air.TotalMoles / transferMolesOne, inletTwo.Air.TotalMoles / transferMolesTwo);
transferMolesOne *= ratio;
transferMolesTwo *= ratio;
}
}
// Actually transfer the gas now.
if (transferMolesOne > 0f)
{
var removed = inletOne.Air.Remove(transferMolesOne);
outlet.AssumeAir(removed);
}
if (transferMolesTwo > 0f)
{
var removed = inletTwo.Air.Remove(transferMolesTwo);
outlet.AssumeAir(removed);
}
}
Component CreateInstance(ComponentFactoryInformation info, ComponentManager cm)
{
Component component = info.CreateInstance(cm);
return(component);
}
public void Init(ComponentManager componentMgrInput)
{
componentManager = componentMgrInput;
OnComponentInitialized();
}
public override void Run()
{
// If there is no state, setup world.
if (State == WorldState.None)
{
// Create ball.
int ballID = EntityManager.CreateEntity();
// Load texture.
Texture2D ballTexture = ContentManager.Load <Texture2D>("square");
// Create components.
HitboxCollisionComponent ballHitbox = new HitboxCollisionComponent(ballID);
PhysicsComponent ballPhysics = new PhysicsComponent(ballID, 0, 0, 0, 0, 1, 150, 150);
PositionComponent ballPosition = new PositionComponent(ballID,
(engine.ScreenWidth / 2) - (ballTexture.Width / 2), (engine.ScreenHeight / 2) - (ballTexture.Height / 2));
Texture2DRenderComponent ballRender = new Texture2DRenderComponent(ballID, 1, ballTexture);
TransformComponent ballTransform = new TransformComponent(ballID, ballTexture.Height, 0, 1, ballTexture.Width);
// Add components.
ComponentManager
.SetComponent(ballHitbox)
.SetComponent(ballPhysics)
.SetComponent(ballPosition)
.SetComponent(ballRender)
.SetComponent(ballTransform);
// Emit ball create event.
EventManager.Emit(new BallCreateEvent(ballID));
// Create player one paddle.
int paddleAID = EntityManager.CreateEntity();
// Load texture.
Texture2D paddleATexture = ContentManager.Load <Texture2D>("paddle");
// Create components.
CollidableComponent paddleACollidable = new CollidableComponent(paddleAID);
PhysicsComponent paddleAPhysics = new PhysicsComponent(paddleAID, 0, 0, 0, 0, 1, 0, 0);
PositionComponent paddleAPosition = new PositionComponent(paddleAID, 0, (engine.ScreenHeight / 2) - (paddleATexture.Height / 2));
Texture2DRenderComponent paddleARender = new Texture2DRenderComponent(paddleAID, 2, paddleATexture);
TransformComponent paddleATransform = new TransformComponent(paddleAID, paddleATexture.Height, 0, 1, paddleATexture.Width);
// Add components.
ComponentManager
.SetComponent(paddleACollidable)
.SetComponent(paddleAPhysics)
.SetComponent(paddleAPosition)
.SetComponent(paddleARender)
.SetComponent(paddleATransform);
// Emit paddle create event.
EventManager.Emit(new PaddleCreateEvent(paddleAID, 1));
// Create player two paddle.
int paddleBID = EntityManager.CreateEntity();
// Load texture.
Texture2D paddleBTexture = ContentManager.Load <Texture2D>("paddle");
// Create components.
CollidableComponent paddleBCollidable = new CollidableComponent(paddleBID);
PhysicsComponent paddleBPhysics = new PhysicsComponent(paddleBID, 0, 0, 0, 0, 1, 0, 0);
PositionComponent paddleBPosition = new PositionComponent(paddleBID, (engine.ScreenWidth - paddleBTexture.Width),
(engine.ScreenHeight / 2) - (paddleBTexture.Height / 2));
Texture2DRenderComponent paddleBRender = new Texture2DRenderComponent(paddleBID, 2, paddleBTexture);
TransformComponent paddleBTransform = new TransformComponent(paddleBID, paddleBTexture.Height, 0, 1, paddleBTexture.Width);
// Add components.
ComponentManager
.SetComponent(paddleBCollidable)
.SetComponent(paddleBPhysics)
.SetComponent(paddleBPosition)
.SetComponent(paddleBRender)
.SetComponent(paddleBTransform);
// Emit paddle create event.
EventManager.Emit(new PaddleCreateEvent(paddleBID, 2));
}
base.Run();
}
/// <see cref="ScenarioDependentComponent.StartImpl"/>
protected override void StartImpl()
{
this.mapWindowBC = ComponentManager.GetInterface <IMapWindowBC>();
}
public MultiplayerMenuScreen(ScreenManager screenManager, GraphicsDevice graphicsDevice) : base(screenManager, graphicsDevice, false)
{
compManager = new ComponentManager();
}
private void configButton_Click(object sender, EventArgs e)
{
ComponentManager.ShowConfiguration("lm");
ObjectList.GridLines = Global.AppSettings.LevelManager.ShowGridInList;
}
public ThemeModeEvent(ComponentManager cm)
{
this.cm = cm;
}
private void OpenLevelEditor(object sender, EventArgs e)
{
Cursor = Cursors.WaitCursor;
ComponentManager.LaunchLevelEditor();
Close();
}
/// <summary>
/// Constructs a SelectionIndicatorView instance.
/// </summary>
public SelectionIndicatorView()
{
this.selectionManager = ComponentManager.GetInterface <ISelectionManagerBC>();
this.fogOfWarBC = ComponentManager.GetInterface <IFogOfWarBC>();
}
public void Update(GameTime gameTime)
{
ComponentManager cm = ComponentManager.GetInstance();
foreach (var entity in cm.GetComponentsOfType <PlayerControlComponent>())
{
PlayerControlComponent playerControl = (PlayerControlComponent)entity.Value;
GamePadState gamepad;
switch (playerControl.ControllerType)
{
case ControllerType.Keyboard:
// Movement
KeyboardState keyboard = Keyboard.GetState();
Vector2 dir = new Vector2();
if (keyboard.IsKeyDown(Keys.W))
{
if (keyboard.IsKeyDown(Keys.D))
{
dir = new Vector2(0.7071f, -0.7071f);
}
else if (keyboard.IsKeyDown(Keys.A))
{
dir = new Vector2(-0.7071f, -0.7071f);
}
else
{
dir = new Vector2(0.0f, -1.0f);
}
}
else if (keyboard.IsKeyDown(Keys.S))
{
if (keyboard.IsKeyDown(Keys.D))
{
dir = new Vector2(0.7071f, 0.7071f);
}
else if (keyboard.IsKeyDown(Keys.A))
{
dir = new Vector2(-0.7071f, 0.7071f);
}
else
{
dir = new Vector2(0.0f, 1.0f);
}
}
else if (keyboard.IsKeyDown(Keys.A))
{
dir = new Vector2(-1.0f, 0.0f);
}
else if (keyboard.IsKeyDown(Keys.D))
{
dir = new Vector2(1.0f, 0.0f);
}
else
{
dir = new Vector2(0.0f, 0.0f);
}
playerControl.Movement.SetDirection(dir);
MouseState mouse = Mouse.GetState();
// Attack
if (keyboard.IsKeyDown(Keys.Space) && previousKeyboardState.IsKeyUp(Keys.Space))
{
playerControl.Attack.SetButton(true);
}
else
{
playerControl.Attack.SetButton(false);
}
// Interact
if (keyboard.IsKeyDown(Keys.E) && previousKeyboardState.IsKeyUp(Keys.E))
{
playerControl.Interact.SetButton(true);
}
else
{
playerControl.Interact.SetButton(false);
}
// Menu
if (keyboard.IsKeyDown(Keys.Escape) && previousKeyboardState.IsKeyUp(Keys.Escape))
{
playerControl.Menu.SetButton(true);
}
else
{
playerControl.Menu.SetButton(false);
}
// Inventory
if (keyboard.IsKeyDown(Keys.C) && previousKeyboardState.IsKeyUp(Keys.C))
{
playerControl.Inventory.SetButton(true);
}
else
{
playerControl.Inventory.SetButton(false);
}
// Back
if (keyboard.IsKeyDown(Keys.Q) && previousKeyboardState.IsKeyUp(Keys.Q))
{
playerControl.Back.SetButton(true);
}
else
{
playerControl.Back.SetButton(false);
}
// Actionbar 1
if (keyboard.IsKeyDown(Keys.D1) && previousKeyboardState.IsKeyUp(Keys.D1))
{
playerControl.ActionBar1.SetButton(true);
}
else
{
playerControl.ActionBar1.SetButton(false);
}
// Actionbar 2
if (keyboard.IsKeyDown(Keys.D2) && previousKeyboardState.IsKeyUp(Keys.D2))
{
playerControl.ActionBar2.SetButton(true);
}
else
{
playerControl.ActionBar2.SetButton(false);
}
// Actionbar 3
if (keyboard.IsKeyDown(Keys.D3) && previousKeyboardState.IsKeyUp(Keys.D3))
{
playerControl.ActionBar3.SetButton(true);
}
else
{
playerControl.ActionBar3.SetButton(false);
}
// Actionbar 4
if (keyboard.IsKeyDown(Keys.D4) && previousKeyboardState.IsKeyUp(Keys.D4))
{
playerControl.ActionBar4.SetButton(true);
}
else
{
playerControl.ActionBar4.SetButton(false);
}
// Set previous keyboard state
previousKeyboardState = Keyboard.GetState();
break;
case ControllerType.Gamepad1:
// Movement
gamepad = GamePad.GetState(PlayerIndex.One);
GamePadInputs(gamepad, previousGamepadState1, playerControl);
// Set previous gamepad state
previousGamepadState1 = GamePad.GetState(PlayerIndex.One);
break;
case ControllerType.Gamepad2:
// Movement
gamepad = GamePad.GetState(PlayerIndex.Two);
GamePadInputs(gamepad, previousGamepadState2, playerControl);
// Set previous gamepad state
previousGamepadState2 = GamePad.GetState(PlayerIndex.Two);
break;
default:
break;
}
}
}
public override void CreateCosmeticChildren(ComponentManager manager)
{
base.CreateCosmeticChildren(manager);
Sheet = new SpriteSheet(ContentPaths.Entities.Furniture.elevator, 32, 32);
}
private void SpawnEnemy(EnemySpawnComponent c, int index)
{
ComponentManager cm = ComponentManager.GetInstance();
Random rand = new Random();
int x, y;
PositionComponent p = new PositionComponent();
List <IComponent> template = new List <IComponent>(c.EnemyTemplate);
int entity;
Random r = new Random();
int shouldEnemyHaveItems = r.Next(0, 3);
for (int i = 0; i < template.Count; i++)
{
template[i] = (IComponent)template[i].Clone();
}
for (int i = 0; i < MaxSpawnTries; i++)
{
x = rand.Next() % c.SpawnMaxRadius;
y = rand.Next() % c.SpawnMaxRadius;
if (c.CollisionComponent == null)
{
p.Position = new Vector2(x, y) + c.SpawnLocation.ToVector2();
template.Add(p);
entity = EntityManager.GetEntityId();
cm.AddComponentsToEntity(entity, template.ToArray());
c.EnemyEntities[index] = entity;
if (shouldEnemyHaveItems > 1)
{
cm.AddComponentsToEntity(entity, new IComponent[] {
new InteractComponent(InteractType.Loot),
new ItemComponent(AddHealth, "Bread",
ItemType.Consumable),
});
}
break;
}
else
{
Rectangle bb = c.CollisionComponent.CollisionBox;
bb.Location = c.SpawnLocation;
bb.Location += new Point(x, y);
if (CollisionSystem.DetectAreaCollision(bb).Count == 0)
{
p.Position = new Vector2(x, y) + c.SpawnLocation.ToVector2();
template.Add(p);
entity = EntityManager.GetEntityId();
cm.AddComponentsToEntity(entity, template.ToArray());
c.EnemyEntities[index] = entity;
if (shouldEnemyHaveItems > 1)
{
cm.AddComponentsToEntity(entity, new IComponent[] {
new InteractComponent(InteractType.Loot),
new ItemComponent(AddHealth, "Bread",
ItemType.Consumable),
});
}
break;
}
}
}
}
public void Draw(SpriteBatch sb, ComponentManager cm, GameTime gameTime)
{
//draw UI
this.drawUI(sb, cm);
//draw everything else
Dictionary <int, LittleRedRobinHood.Component.Collide> collides = cm.getCollides();
SpriteEffects effect = SpriteEffects.None;
foreach (KeyValuePair <int, LittleRedRobinHood.Component.Sprite> sp in cm.getSprites())
{
int spriteX = cm.getCollides()[sp.Value.entityID].hitbox.X;
int spriteY = cm.getCollides()[sp.Value.entityID].hitbox.Y;
Texture2D image = cm.getSprites()[sp.Value.entityID].sprite;
int spriteWidth = cm.getSprites()[sp.Value.entityID].width;
int spriteHeight = cm.getSprites()[sp.Value.entityID].height;
//check if sprite is an animated sprite
if (sp.Value.animated)
{
int column = 0;
float row = 0;
//Patrol animation
if (cm.getEntities()[sp.Value.entityID].isPatrol)
{
row = 0;
column = 0;
//Check which way patrol is facing
if (cm.getPatrols()[sp.Value.entityID].is_right)
{
effect = SpriteEffects.None;
}
else
{
effect = SpriteEffects.FlipHorizontally;
}
//flying patrols
//check whether or not they are shackled/frozen
if (cm.getCollides()[sp.Value.entityID].numShackled == 0)
{
column = patrolCurrentFrame;
row = 0;
}
//grab the current animation frame
Rectangle sourceRectangle = new Rectangle(spriteWidth * column, (int)(spriteHeight * row), spriteWidth, spriteHeight);
Rectangle destinationRectangle = new Rectangle(spriteX, spriteY, spriteWidth, spriteHeight);
//draw the current animation frame
sb.Draw(image, destinationRectangle, sourceRectangle, Color.White, 0, new Vector2(0, 0), effect, 1);
//update the current frames
timePatrol += (float)gameTime.ElapsedGameTime.TotalSeconds;
while (timePatrol > frameTime)
{
// Play the next frame in the SpriteSheet
patrolCurrentFrame++;
// reset elapsed time
timePatrol = 0f;
}
//check out of bounds
if (patrolCurrentFrame >= patrolTotalFrame)
{
patrolCurrentFrame = 0;
}
}
}
else //no animation, so just draw
{
//Rotate if projectile BUT NOT PINECONE
if (cm.getEntities()[sp.Value.entityID].isProjectile && cm.getProjectiles()[sp.Value.entityID].isArrow && !cm.getEntities()[sp.Value.entityID].isPatrol)
{
sb.Draw(image, new Rectangle(spriteX, spriteY, spriteWidth, spriteHeight), null, Color.White, (float)cm.getProjectiles()[sp.Value.entityID].angle + (float)Math.PI, new Vector2(spriteWidth / 2, spriteHeight / 2), SpriteEffects.None, 1);
}
else
{
sb.Draw(image, new Rectangle(spriteX, spriteY, spriteWidth, spriteHeight), Color.White);
}
}
}
}
public void DrawPlayer(SpriteBatch sb, ComponentManager cm, GameTime gameTime)
{
SpriteEffects effect = SpriteEffects.None;
int column = 0;
float row = 0;
int spriteX = cm.getCollides()[cm.playerID].hitbox.X;
int spriteY = cm.getCollides()[cm.playerID].hitbox.Y;
Texture2D image = cm.getSprites()[cm.playerID].sprite;
int spriteWidth = cm.getSprites()[cm.playerID].width;
int spriteHeight = cm.getSprites()[cm.playerID].height;
if (cm.getPlayers()[cm.playerID].is_right)
{
effect = SpriteEffects.None;
}
else
{
effect = SpriteEffects.FlipHorizontally;
}
//shooting??
if (cm.getPlayers()[cm.playerID].shooting)
{
spriteWidth = 73;
spriteHeight = 58;
column = playerCurrentFrame;
playerTotalFrame = 5;
row = 3;
spriteSpeed = 5;
}
//jumping
else if (cm.getPlayers()[cm.playerID].jumping)
{
spriteWidth = 36;
spriteHeight = 62; //wonky
if (cm.getPlayers()[cm.playerID].dy < 0)
{
playerTotalFrame = 2;
column = playerCurrentFrame;
row = 3.75f;
}
//falling
else if (cm.getPlayers()[cm.playerID].dy >= 0)
{
playerTotalFrame = 1;
column = 2;
row = 3.75f;
}
}
//falling
else if (cm.getPlayers()[cm.playerID].dy > 6)
{
spriteWidth = 36;
spriteHeight = 62;
playerTotalFrame = 1;
column = 2;
row = 3.75f; //because height is not 58 like everything else
}
//running
else if (cm.getPlayers()[cm.playerID].running)
{
spriteWidth = 46;
spriteHeight = 58;
column = playerCurrentFrame;
playerTotalFrame = 10;
row = 1;
}
//idle
else
{
spriteWidth = 36;
spriteHeight = 58;
column = playerCurrentFrame;
playerTotalFrame = 10;
row = 0;
}
//grab the current animation frame
Rectangle sourceRectangle = new Rectangle(spriteWidth * column, (int)(spriteHeight * row), spriteWidth, spriteHeight);
Rectangle destinationRectangle = new Rectangle(spriteX, spriteY, spriteWidth, spriteHeight);
//Reset the collide hitbox size in case it changes (which it does with the Player)
spriteWidth = 36; //NOT SURE ABOUT THIS OK but it works fine so that's good
spriteHeight = 58;
//cm.getCollides()[sp.Value.entityID].hitbox = destinationRectangle;
//Make it so that shooting sprite isn't really off
if (cm.getPlayers()[cm.playerID].shooting && !cm.getPlayers()[cm.playerID].is_right)
{
destinationRectangle.X = destinationRectangle.X - (73 - 36);
}
//draw the current animation frame
sb.Draw(image, destinationRectangle, sourceRectangle, Color.White, 0, new Vector2(0, 0), effect, 1);
//update the current frames
timePlayer += (float)gameTime.ElapsedGameTime.TotalSeconds;
while (timePlayer > frameTime)
{
// Play the next frame in the SpriteSheet
playerCurrentFrame++;
// reset elapsed time
timePlayer = 0f;
}
if (playerCurrentFrame >= playerTotalFrame)
{
playerCurrentFrame = 0;
if (cm.getPlayers()[cm.playerID].shooting)
{
playerCurrentFrame = 3;
}
}
}
public ElevatorPlatform(ComponentManager Manager, Vector3 Position) :
base(Manager, "Elevator Track", Matrix.CreateTranslation(Position), new Vector3(1.0f, 0.1f, 1.0f), Vector3.Zero)
{
CollisionType = CollisionType.Static;
CreateCosmeticChildren(Manager);
}
public object Process(ProcessRequest request)
{
var assembly = string.Empty;
var typeName = string.Empty;
var methodName = string.Empty;
var appDomainKey = string.Empty;
MuleMessage result;
MuleMessage muleMessage = new MuleMessage();
IMuleInstrumentation instrumentation = new MuleInstrumentation(Instrument, request.NotifyEvents);
if (string.IsNullOrWhiteSpace(request.AssemblyName))
{
throw new ArgumentNullException("assemblyName");
}
var split = request.AssemblyName.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (split.Length == 0)
{
throw new ArgumentException("Invalid .NET Assembly Type. The .NET Assembly Type should be: partially qualified \"Namespace.Type, AssemblyName\" or fully qualified name \"Namespace.Type, AssemblyName, [Version], [Culture], [PublicKey]\"");
}
typeName = split[0].Trim();
if (split.Length == 2)
{
assembly = split[1].Trim();
appDomainKey = string.Format("{0}_{1}", request.AssemblyPath, assembly);
}
else // remove type from assembly name
{
assembly = request.AssemblyName.Substring(request.AssemblyName.IndexOf(",") + 1).Trim();
appDomainKey = assembly;
}
if (string.IsNullOrWhiteSpace(request.MethodName))
{
throw new ArgumentNullException("The method name cannot be empty.");
}
// add trust to key
appDomainKey = string.Concat(appDomainKey, request.FullTrust);
// add timestamp to assembly not in GAC
if (request.AssemblyPath.EndsWith(".dll"))
{
appDomainKey = string.Concat(appDomainKey, "_", File.GetLastWriteTime(request.AssemblyPath).Ticks.ToString());
}
methodName = request.MethodName;
muleMessage.Arguments = request.MethodArguments;
muleMessage.InboundProperties = new ReadOnlyDictionary <string, object>(request.InboundProperties);
muleMessage.SessionProperties = request.SessionProperties;
muleMessage.InvocationProperties = request.InvocationProperties;
muleMessage.OutboundProperties = request.OutboundProperties;
var requestPath = muleMessage.InboundProperties.ContainsKey(MuleMessage.RequestKey) ? muleMessage.InboundProperties[MuleMessage.RequestKey] : string.Empty;
muleMessage.Payload = muleMessage.Arguments.ContainsKey(MuleMessage.DataKey) ? muleMessage.Arguments[MuleMessage.DataKey] : requestPath;
var queryString = muleMessage.InboundProperties.ContainsKey("http.query.string") ?
muleMessage.InboundProperties["http.query.string"].ToString().Replace("{", "").Replace("}", "").Replace(" ", "").Replace(",", "&") :
string.Empty;
muleMessage.QueryStrings = string.IsNullOrWhiteSpace(queryString) ? new NameValueCollection() : HttpUtility.ParseQueryString(queryString);
if (string.IsNullOrWhiteSpace(request.AssemblyPath))
{
request.AssemblyPath = componentPath;
}
componentManager = appDomains.GetOrAdd(appDomainKey,
(key) =>
{
var cm = new ComponentManager();
cm.AppDomainKey = appDomainKey;
//Bypass assemblies installed in the GAC
if (request.AssemblyPath.EndsWith(".dll"))
{
// Add FileSystemWatcher to watch any updates on the requested assembly, if changes occur, unload AppDoamin and create a new one
var watcher = new FileSystemWatcher();
watcher.Path = Path.GetDirectoryName(request.AssemblyPath);
watcher.NotifyFilter = NotifyFilters.LastWrite;
watcher.Filter = "*.dll";
watcher.Changed += (o, e) =>
{
var componentWatcher = cm;
watcher.EnableRaisingEvents = false;
var retry = 0;
var maxRetries = 10;
// wait until AppDomain is idle to unload it
while (componentWatcher.State != ComponentState.Idle && retry < maxRetries)
{
Thread.Sleep(15000);
retry++;
}
AppDomain.Unload(componentWatcher.LoaderDomain);
appDomains.TryRemove(appDomainKey, out componentWatcher);
if (retry >= maxRetries)
{
throw new Exception(string.Format("The AppDomain couldn't be unloaded normally after {0} attempts.", retry));
}
};
watcher.EnableRaisingEvents = true;
}
cm.Init(componentPath, request.AssemblyPath, request.FullTrust, logger);
return(cm);
});
try
{
// Execute method
string assemblyName;
// Check if it's an assembly in the GAC or one specified by the user
if (request.AssemblyPath.EndsWith(".dll"))
{
assemblyName = AssemblyName.GetAssemblyName(request.AssemblyPath).FullName;
}
else
{
assemblyName = assembly;
}
if (request.Log)
{
Log(string.Format("Start execution of component: {0}.{1}", typeName, methodName));
}
//logger.Write(string.Format("Start execution of component: {0}.{1}", typeName, methodName), LoggerLevel.Trace);
result = (MuleMessage)componentManager.Execute(assemblyName, typeName, methodName, muleMessage, request.IsSingleton, instrumentation);
//logger.Write("End execution {0}.{1}", LoggerLevel.Trace, typeName, methodName);
if (request.Log)
{
Log(string.Format("End execution {0}.{1}", typeName, methodName));
}
}
catch (Exception ex)
{
Log(string.Format("Error executing component {0}.{1} : {2}", typeName, methodName, ex.Message));
throw;
}
return(ToProcessRequest(result));
}
/// <see cref="IComponent.Start"/>
public void Start()
{
this.scenarioManager = ComponentManager.GetInterface <IScenarioManagerBC>();
this.selectionManager = ComponentManager.GetInterface <ISelectionManagerBC>();
this.mapWindowBC = ComponentManager.GetInterface <IMapWindowBC>();
}
internal ComponentsRpcService(ComponentManager componentManager)
{
_componentManager = componentManager;
}
public override void Update(float frameTime)
{
base.Update(frameTime);
var currentTime = _gameTiming.CurTime;
// Can't see any I guess?
if (_attachedEntity == null || _attachedEntity.Deleted)
{
return;
}
var viewbox = _eyeManager.GetWorldViewport().Enlarged(2.0f);
foreach (var comp in ComponentManager.EntityQuery <DoAfterComponent>(true))
{
var doAfters = comp.DoAfters.ToList();
var compPos = comp.Owner.Transform.WorldPosition;
if (doAfters.Count == 0 ||
comp.Owner.Transform.MapID != _attachedEntity.Transform.MapID ||
!viewbox.Contains(compPos))
{
comp.Disable();
continue;
}
var range = (compPos - _attachedEntity.Transform.WorldPosition).Length +
0.01f;
if (comp.Owner != _attachedEntity &&
!ExamineSystemShared.InRangeUnOccluded(
_attachedEntity.Transform.MapPosition,
comp.Owner.Transform.MapPosition, range,
entity => entity == comp.Owner || entity == _attachedEntity))
{
comp.Disable();
continue;
}
comp.Enable();
var userGrid = comp.Owner.Transform.Coordinates;
// Check cancellations / finishes
foreach (var(id, doAfter) in doAfters)
{
var elapsedTime = (currentTime - doAfter.StartTime).TotalSeconds;
// If we've passed the final time (after the excess to show completion graphic) then remove.
if (elapsedTime > doAfter.Delay + ExcessTime)
{
comp.Remove(doAfter);
continue;
}
// Don't predict cancellation if it's already finished.
if (elapsedTime > doAfter.Delay)
{
continue;
}
// Predictions
if (doAfter.BreakOnUserMove)
{
if (!userGrid.InRange(EntityManager, doAfter.UserGrid, doAfter.MovementThreshold))
{
comp.Cancel(id, currentTime);
continue;
}
}
if (doAfter.BreakOnTargetMove)
{
if (EntityManager.TryGetEntity(doAfter.TargetUid, out var targetEntity) &&
!targetEntity.Transform.Coordinates.InRange(EntityManager, doAfter.TargetGrid,
doAfter.MovementThreshold))
{
comp.Cancel(id, currentTime);
continue;
}
}
}
var count = comp.CancelledDoAfters.Count;
// Remove cancelled DoAfters after ExcessTime has elapsed
for (var i = count - 1; i >= 0; i--)
{
var cancelled = comp.CancelledDoAfters[i];
if ((currentTime - cancelled.CancelTime).TotalSeconds > ExcessTime)
{
comp.Remove(cancelled.Message);
}
}
}
}
public SteamPoweredBuildBuff(ComponentManager Manager) : base(Manager)
{
}
private void levelManagerButton_Click(object sender, EventArgs e)
{
ComponentManager.LaunchLevelManager();
Close();
}
public void Update(GameTime gameTime)
{
List <ulong> comps = ComponentManager.GetAllEntitiesWithComp <TransformComponent>();
foreach (ulong c in comps)
{
CameraComponent camera = ComponentManager.GetComponent <CameraComponent>(c);
TransformComponent transform = ComponentManager.GetComponent <TransformComponent>(c);
//float leftRightRot = 0;
//float upDownRot = 0;
//float turningSpeed = (float)gameTime.ElapsedGameTime.TotalMilliseconds / 1000f;
//turningSpeed += .025f;
if (Keyboard.GetState().IsKeyDown(Keys.D))
{
transform.position.X += transform.speed.X * gameTime.ElapsedGameTime.Milliseconds;
//leftRightRot += turningSpeed;
}
if (Keyboard.GetState().IsKeyDown(Keys.A))
{
transform.position.X -= transform.speed.X * gameTime.ElapsedGameTime.Milliseconds;
//leftRightRot -= turningSpeed;
}
if (Keyboard.GetState().IsKeyDown(Keys.W))
{
transform.position.Z -= transform.speed.Z * gameTime.ElapsedGameTime.Milliseconds;
//upDownRot += turningSpeed;
}
if (Keyboard.GetState().IsKeyDown(Keys.S))
{
transform.position.Z += transform.speed.Z * gameTime.ElapsedGameTime.Milliseconds;
//upDownRot -= turningSpeed;
}
if (Keyboard.GetState().IsKeyDown(Keys.Space))
{
transform.position.Y += transform.speed.Y * gameTime.ElapsedGameTime.Milliseconds;
//upDownRot += turningSpeed;
}
if (Keyboard.GetState().IsKeyDown(Keys.LeftShift))
{
transform.position.Y -= transform.speed.Y * gameTime.ElapsedGameTime.Milliseconds;
//upDownRot -= turningSpeed;
}
Vector3 axis = Vector3.Zero;
float angle = (float)-gameTime.ElapsedGameTime.TotalMilliseconds * .01f;
if (Keyboard.GetState().IsKeyDown(Keys.Up))
{
axis = new Vector3(1f, 0, 0);
//upDownRot += turningSpeed;
}
if (Keyboard.GetState().IsKeyDown(Keys.Down))
{
axis = new Vector3(-1f, 0, 0);
//upDownRot += turningSpeed;
}
if (Keyboard.GetState().IsKeyDown(Keys.Right))
{
axis = new Vector3(0, -1f, 0);
//upDownRot += turningSpeed;
}
if (Keyboard.GetState().IsKeyDown(Keys.Left))
{
axis = new Vector3(0, 1f, 0);
//upDownRot += turningSpeed;
}
//Quaternion extraRot = Quaternion.CreateFromAxisAngle(new Vector3(0, 0, -1), leftRightRot)
// * Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), upDownRot);
Quaternion extraRot = Quaternion.CreateFromAxisAngle(axis, angle);
extraRot.Normalize();
transform.qRot *= extraRot;
}
}
private void OpenReplayManager(object sender, EventArgs e)
{
Cursor = Cursors.WaitCursor;
ComponentManager.LaunchReplayManager();
Close();
}
protected void OnDrawingareaExposeEvent(object o, Gtk.ExposeEventArgs args)
{
Gdk.EventExpose expose = args.Args[0] as Gdk.EventExpose;
Gdk.Window win = expose.Window;
int width, height;
win.GetSize(out width, out height);
Gdk.Rectangle exposeRect = expose.Area;
bool fulldraw = width == exposeRect.Width && height == exposeRect.Height;
win.DrawRectangle(Style.LightGC(StateType.Normal), true, exposeRect);
if (GetContentDelegate == null)
{
return; // todo: an error message could be displayed
}
int offset = (int)vscrollbar1.Value;
if (fulldraw)
{
TopVisibleRow = offset;
BottomVisibleRow = offset;
}
if (ConstantHeight == 0)
{
DetermineLayout();
if (ConstantHeight == 0)
{
return; // should never happen
}
}
int maxHScrollRange = 0;
int dy = exposeRect.Top;
offset += dy / ConstantHeight;
dy -= dy % ConstantHeight;
Gdk.GC background = new Gdk.GC((Gdk.Drawable)base.GdkWindow);
Gdk.GC text = new Gdk.GC((Gdk.Drawable)base.GdkWindow);
ColumnControl.Column[] columns = mColumnControl.GetVisibleColumnsInDrawOrder();
for (int row = offset; row < RowCount; row++)
{
int dx = -(int)hscrollbar1.Value;
Gdk.Rectangle rect = new Gdk.Rectangle(dx, dy, 0, ConstantHeight);
System.Drawing.Color backColor = System.Drawing.Color.WhiteSmoke;
System.Drawing.Color textColor = System.Drawing.Color.Black;
if (row == CurrentRow)
{
backColor = System.Drawing.Color.DarkGray;
}
else if (m_Selection.Contains(row))
{
backColor = System.Drawing.Color.LightGray;
}
else if (GetColorDelegate != null)
{
GetColorDelegate(row, ref backColor, ref textColor);
}
background.RgbFgColor = new Gdk.Color(backColor.R, backColor.G, backColor.B);
text.RgbFgColor = new Gdk.Color(textColor.R, textColor.G, textColor.B);
int totalwidth = 0;
for (int c = 0; c < columns.Length; c++)
{
ColumnControl.Column column = columns[c];
int columnIndex = column.SortOrder;
int xwidth = column.Width;
rect = new Gdk.Rectangle(rect.Left, rect.Top, xwidth + mColumnControl.GripperWidth, ConstantHeight);
if (c == columns.Length - 1)
{
rect.Width = Math.Max(rect.Width, exposeRect.Right - rect.Left + 1);
}
object content = GetContentDelegate(row, columnIndex);
if (content is Gdk.Pixbuf)
{
Gdk.Pixbuf image = (Gdk.Pixbuf)content;
win.DrawRectangle(background, true, rect);
dx += 2;
image.RenderToDrawable(win, text, 0, 0, dx, dy, image.Width, image.Height, Gdk.RgbDither.Normal, 0, 0);
dx += xwidth + mColumnControl.GripperWidth - 2;
rect.Offset(xwidth + mColumnControl.GripperWidth, 0);
totalwidth += 2 + rect.Width;
}
else
{
column.LineLayout.SetText(content.ToString());
win.DrawRectangle(background, true, rect);
dx += 2;
win.DrawLayout(text, dx, dy, column.LineLayout);
dx += xwidth + mColumnControl.GripperWidth - 2;
rect.Offset(xwidth + mColumnControl.GripperWidth, 0);
int dwidth, dheight;
column.LineLayout.GetPixelSize(out dwidth, out dheight);
totalwidth += 2 + mColumnControl.GripperWidth + dwidth;
}
}
maxHScrollRange = Math.Max(maxHScrollRange, totalwidth);
dy += ConstantHeight;
if (dy > exposeRect.Bottom)
{
break;
}
if (fulldraw && exposeRect.Height - dy >= ConstantHeight)
{
BottomVisibleRow++;
}
}
if (fulldraw)
{
int pageSize = BottomVisibleRow - TopVisibleRow;
if (vscrollbar1.Adjustment.PageSize != pageSize)
{
vscrollbar1.Adjustment.PageSize = pageSize;
vscrollbar1.Adjustment.PageIncrement = pageSize;
}
if (maxHScrollRange > 0 && maxHScrollRange > hscrollbar1.Value)
{
hscrollbar1.SetRange(0, maxHScrollRange);
}
// position current row inside visible area
// TODO: please think about, because of double redraw a more sophisticated solution could be possible
if (CurrentRow >= 0 && CurrentRow < RowCount)
{
if (CurrentRow < TopVisibleRow)
{
OffsetCursor(TopVisibleRow - CurrentRow);
}
else if (CurrentRow > BottomVisibleRow)
{
OffsetCursor(BottomVisibleRow - CurrentRow);
}
}
}
#if DEBUG2
if (ComponentManager != null)
{
String t1 = String.Format("Expose.Area={0}, size={1}.{2}",
expose.Area.ToString(), width, height);
String t2 = String.Format("{0} T={1} B={2}", fulldraw ? "FULL" : "PART", TopVisibleRow, BottomVisibleRow);
ComponentManager.MessageWriteLineInvoke(String.Format("{0} {1}", t1, t2));
}
#endif
}
