/// <summary>
/// General method to obtain a drawing object for an entity, looks if a
/// object exists for that entity, if not one is created. Therefore, it is checked if
/// method for object creation has been speciefied for the type of entity
/// and calls the corresponding method, otherwise throughs an exception.
/// </summary>
/// <param name="entity">Entity for which drawing object is required</param>
/// <returns>Drawing object for entity</returns>
public DrawingObject DrawingObjectPerEntity(Entity entity)
{
// if entity drawing object hasn't been created
// the corresponding method is looked up
if (!_drawingObjectPerEntity.ContainsKey(entity))
{
// in case no method to create a drawing object for the entity is provided an
// exception is thrown
if (!EntityVisualizationObjectCreatingMethodsPerType.ContainsKey(entity.GetType()))
{
throw new InvalidOperationException(String.Format("Creation of Drawing Object for Entity {0} is not provided", entity.ToString()));
}
// create the drawing object
DrawingObject newDrawingObject = EntityVisualizationObjectCreatingMethodsPerType[entity.GetType()](entity);
// add drawing obecjt to system, has to be set to visual manually by user
DrawingSystem.AddObject(newDrawingObject);
// drawing object is stored in the dictionary
_drawingObjectPerEntity.Add(entity, newDrawingObject);
} // end if
// the right key is now in the dictionary
return(_drawingObjectPerEntity[entity]);
} // end of DrawingObjectPerEntity
protected Dictionary <int, AbstractEntity> menuItemList = new Dictionary <int, AbstractEntity>(); // For when selecting item to pick up etc...
public AbstractRoguelike(int maxLogEntries)
{
this.ecs = new BasicEcs(this);
this.mapData = new MapData();
this.gameLog = new GameLog(maxLogEntries);
new CloseCombatSystem(this.ecs);
new MovementSystem(this.ecs, this.mapData);
this.CreateData();
this.view = new DefaultRLView(this);
this.drawingSystem = new DrawingSystem(this.view, this);
this.checkVisibilitySystem = new CheckMapVisibilitySystem(this.ecs, this.mapData);
new ShootOnSightSystem(this.ecs, this.checkVisibilitySystem, this.ecs.entities);
this.checkVisibilitySystem.process(this.playersUnits);
this.damageSystem = new DamageSystem(this.ecs, this.gameLog);
this.explosionSystem = new ExplosionSystem(this.ecs, this.checkVisibilitySystem, this.damageSystem, this.mapData, this.ecs.entities);
new TimerCountdownSystem(this.ecs, this.explosionSystem);
this.pickupItemSystem = new PickupDropSystem();
this.effectsSystem = new EffectsSystem(this.ecs);
new ThrowingSystem(this.ecs, this.mapData, this.gameLog);
new ShootingSystem(this.ecs, this.gameLog);
// Draw screen
this.drawingSystem.Process(this.effectsSystem.effects);
}
public void AddSystem(ISystem system)
{
this.systems.Add(system);
if (system is DrawingSystem)
{
this.drawingSystem = system as DrawingSystem;
}
}
} // end of DrawingObjectPerEntity
#endregion
#region RemoveDrawingObjectPerEntity
/// <summary>
/// Removes the drawing object for an entity
/// </summary>
/// <param name="entity">Entity for which an object should be removed</param>
public void RemoveDrawingObjectPerEntity(Entity entity)
{
if (_drawingObjectPerEntity.ContainsKey(entity))
{
DrawingSystem.RemoveObject(_drawingObjectPerEntity[entity]);
}
_drawingObjectPerEntity.Remove(entity);
} // end of RemoveDrawingObjectPerEntity
public Engine(IEntityManager entityManager, WorldSystem worldSystem, MovementSystem movementSystem,
DrawingSystem drawingSystem, VisionSystem visionSystem, TimeTrackingSystem timeTrackingSystem)
{
this.entityManager = entityManager;
this.worldSystem = worldSystem;
this.movementSystem = movementSystem;
this.drawingSystem = drawingSystem;
this.visionSystem = visionSystem;
this.timeTrackingSystem = timeTrackingSystem;
}
//and so on
//static PhysicsSystem physicsSystem;
//static ScoreSystem scoreSystem;
internal static void Init()
{
entitiesManager = new EntitiesManager();
drawingSystem = new DrawingSystem(entitiesManager);
movingSystem = new MovingSystem(entitiesManager);
//and so on
CreateDemoEntities();
}
} // end of GetServedStart
#endregion
#region DrawHoldingEntity
/// <summary>
/// Visualized a dynamic holding entity (in this example a queue) by adding clients in the rectangle,
/// no overflow handling (will draw infinitely)
/// </summary>
/// <param name="holdingEntity"></param>
public void DrawHoldingEntity(IDynamicHoldingEntity holdingEntity)
{
DrawDynamicHoldingEntity drawFoHold = (DrawDynamicHoldingEntity)DrawingObjectPerEntity((Entity)holdingEntity);
if (drawFoHold.MaxNumberPerson < holdingEntity.HoldedEntities.Count)
{
drawFoHold.DrawPersonCount.StringToDraw = holdingEntity.HoldedEntities.Count.ToString();
if (!DrawingSystem.DrawingObjects.Contains(drawFoHold.DrawPersonCount))
{
DrawingSystem.AddObject(drawFoHold.DrawPersonCount);
}
foreach (DrawingObject drawObject in holdingEntity.HoldedEntities.Select(p => DrawingObjectPerEntity(p)))
{
drawObject.SetPosition(drawFoHold.DrawPersonCount.CurrentPosition - new Vector(-30, 0));
} // end foreach
}
else
{
if (DrawingSystem.DrawingObjects.Contains(drawFoHold.DrawPersonCount))
{
DrawingSystem.RemoveObject(drawFoHold.DrawPersonCount);
}
int entitiesDrawn = 0;
double entityW = drawFoHold.SlotWidth;
double entityH = drawFoHold.SlotHeight;
for (int i = 0; i < drawFoHold.NumberPersonVertical; i++)
{
for (int j = 0; j < drawFoHold.NumberPersonHorizontal; j++)
{
if (entitiesDrawn == holdingEntity.HoldedEntities.Count)
{
return;
}
DrawingObject drawEntity = DrawingObjectPerEntity(holdingEntity.HoldedEntities[entitiesDrawn]);
drawEntity.SetPosition(drawFoHold.CurrentPosition + new Vector(j * entityW + drawFoHold.SlotWidth / 2, i * entityH));
entitiesDrawn++;
} // end for
} // end for
} // end if
} // end of DrawHoldingEntity
static void Main(string[] args)
{
#region Composition Root
var entityManager = new EntityManager();
var drawingComponentTypes =
new Type[] {
typeof(VisibleComponent),
typeof(PhysicalComponent)
};
var drawingSystem = new DrawingSystem(drawingComponentTypes);
var visibleComponent =
new PoolDecorator <VisibleComponent>(
new ComponentPool <VisibleComponent>(), entityManager, drawingSystem);
var physicalComponent =
new PoolDecorator <PhysicalComponent>(
new ComponentPool <PhysicalComponent>(), entityManager, drawingSystem);
entityManager.AddSystems(drawingSystem);
entityManager.AddComponentPool(visibleComponent);
entityManager.AddComponentPool(physicalComponent);
#endregion
var entity = new Entity(entityManager.CreateEntity());
entityManager.AddComponentToEntity(
entity.EntityId,
new PhysicalComponent()
{
X = 0, Y = 0
});
Console.WriteLine($"Added physical component, number of drawn entities: {drawingSystem.SystemEntities.Count}.");
entityManager.AddComponentToEntity(
entity.EntityId,
new VisibleComponent()
{
Appearance = Appearance.Monster
});
Console.WriteLine($"Added visible component, number of drawn entities: {drawingSystem.SystemEntities.Count}.");
entityManager.RemoveComponentFromEntity <VisibleComponent>(entity.EntityId);
Console.WriteLine($"Removed visible component, number of drawn entities: {drawingSystem.SystemEntities.Count}.");
Console.ReadLine();
}
} // end of NumberSlotAssignString
#endregion
//--------------------------------------------------------------------------------------------------
// Methods
//--------------------------------------------------------------------------------------------------
#region AdditionalStaticVisualization
/// <summary>
/// Calls base class method and additiona visualization for string captions
/// </summary>
/// <param name="initializationTime">Time at which static visualization is generated</param>
/// <param name="simModel">Simulation model for which the visuslization is generated</param>
/// <param name="parentControlUnit">Control unit that is visualized</param>
public override void AdditionalStaticVisualization(DateTime initializationTime, SimulationModel simModel, ControlUnit parentControlUnit)
{
base.AdditionalStaticVisualization(initializationTime, simModel, parentControlUnit);
DrawingObjectString personWaitingforSlotString = new DrawingObjectString(Position - new Vector(0, 50), "Patients Waiting for Slot: ", CustomStringAlignment.Left, 24, Colors.Gray);
_numberSlotWaitString = new DrawingObjectString(Position - new Vector(-500, 50), "0", CustomStringAlignment.Left, 24, Colors.Gray);
DrawingSystem.AddObject(personWaitingforSlotString);
DrawingSystem.AddObject(NumberSlotWaitString);
DrawingObjectString personWaitingforSlotAssignString = new DrawingObjectString(Position - new Vector(0, 100), "Patients Waiting to be assigned to Slot: ", CustomStringAlignment.Left, 24, Colors.Gray);
_numberSlotAssingString = new DrawingObjectString(Position - new Vector(-500, 100), "0", CustomStringAlignment.Left, 24, Colors.Gray);
DrawingSystem.AddObject(NumberSlotAssignString);
DrawingSystem.AddObject(personWaitingforSlotAssignString);
} // end of AdditionalStaticVisualization
} // end of DrawHoldingEntity
#endregion
#region AdditionalStaticVisualization
/// <summary>
/// Static visualization of model, draws servers and queues
/// </summary>
/// <param name="initializationTime">Time static visualization is initialized</param>
/// <param name="simModel">Simulation model to draw</param>
/// <param name="parentControlUnit">Control unit to draw</param>
public override void AdditionalStaticVisualization(DateTime initializationTime, SimulationModel simModel, ControlUnit parentControlUnit)
{
ControlUnitQueuingModel queueControl = (ControlUnitQueuingModel)parentControlUnit;
DrawingSystem.ClearSystem();
for (int i = 0; i < queueControl.Queues.Count; i++)
{
DrawingObject drawForQueue = DrawingObjectPerEntity(queueControl.Queues[i]);
drawForQueue.SetPosition(new Point(20, i * 80));
} // end for
for (int i = 0; i < queueControl.Servers.Count; i++)
{
DrawingObject drawForServer = DrawingObjectPerEntity(queueControl.Servers[i]);
drawForServer.SetPosition(new Point(300, i * 80));
} // end for
} // end of AdditionalStaticVisualization
} // end of
#endregion
#region CreateModel
public void CreateModel()
{
//_simulationModel = new SimulationModelQueuing((DateTime)DatePickerStartDate.SelectedDate,
// (DateTime)DatePickerEndDate.SelectedDate,
// 2,
// 3,
// 5,
// 10);
DrawingSystem.ClearSystem();
_simulationModel = new HospitalSimulationModelWithVisualization((DateTime)DatePickerStartDate.SelectedDate,
(DateTime)DatePickerEndDate.SelectedDate);
_simulationEngine = new SimulationEngine();
SimulationEngine.LoggingEngine = new BaseLoggingEngine(SimulationModel);
SimulationEngine.CreateEventLog = true;
SimulationEngine.SimulationModel = SimulationModel;
SimulationModel.Initialize(SimulationEngine);
SimulationModel.InitializeVisualization(DrawingSystem);
} // end of CreateModel
//--------------------------------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------------------------------
#region MainWindow
public MainWindow()
{
Loaded += WainWindowOnLoad;
InitializeComponent();
#region InitalizeStartEndDate
DatePickerStartDate.SelectedDate = DateTime.Now;
DatePickerEndDate.SelectedDate = DateTime.Now.AddMonths(1);
#endregion
#region InitiaizeDrawingSystem
_drawingSystem = new DrawingOnCoordinateSystem(0, 300);
DrawingSystem.VerticalAlignment = VerticalAlignment.Stretch;
DrawingSystem.HorizontalAlignment = HorizontalAlignment.Stretch;
DrawingSystem.SetValue(Grid.RowProperty, 1);
DrawingSystem.SetValue(Grid.ColumnProperty, 1);
DrawingSystem.SetValue(Grid.ColumnSpanProperty, 2);
MainGrid.Children.Add(DrawingSystem);
#endregion
#region IntiliazeBackgroundWorker
_backGroundWorkerNonVisualization = new BackgroundWorker();
_backGroundWorkerNonVisualization.WorkerReportsProgress = true;
_backGroundWorkerNonVisualization.WorkerSupportsCancellation = true;
_backGroundWorkerNonVisualization.DoWork += new System.ComponentModel.DoWorkEventHandler(BackGroundWorkerNonVisualizationDoWork);
_backGroundWorkerNonVisualization.ProgressChanged += new ProgressChangedEventHandler(BackGroundWorkerNonVisualizationProgressChanged);
_backGroundWorkerNonVisualization.RunWorkerCompleted += new RunWorkerCompletedEventHandler(BackGroundWorkerNonVisualizationRunWorkerCompleted);
#endregion
ComboBoxTimeBase.SelectedIndex = 0;
_simulationRunning = false;
_simulationInitialized = false;
_simulationTimer = new DispatcherTimer();
SimulationTimer.Tick += PlaySimulationTick;
TextBoxSimSpeed.Text = SimulationSpeed.ToString();
CreateModel();
#region InitializeClock
_simulationDisplayClock = new DrawAnalogClockWithDate(Colors.Black, 0, 0);
SimulationDisplayClock.VerticalAlignment = VerticalAlignment.Stretch;
SimulationDisplayClock.HorizontalAlignment = HorizontalAlignment.Stretch;
SimulationDisplayClock.SetValue(Grid.RowProperty, 0);
SimulationDisplayClock.SetValue(Grid.ColumnProperty, 2);
MainGrid.Children.Add(SimulationDisplayClock);
Loaded += delegate
{
SimulationDisplayClock.Initialize(SimulationModel.StartTime);
};
#endregion
} // end of MainWindow
} // end of GetServedStart
#endregion
#region GetServedEnd
/// <summary>
/// Method to change visualiztion at service end, remove client drawing object from drawing system
/// </summary>
/// <param name="activity">GetServed activity</param>
/// <param name="time">Time activity is ended</param>
public void GetServedEnd(Activity activity, DateTime time)
{
DrawingSystem.RemoveObject(DrawingObjectPerEntity(((ActivityGetServed)activity).Client));
} // end of GetServedStart
