private IEnumerator BackOutCoroutine()
{
Locked = true;
for (int i = 0; i < activeWorkStation.basketSlots.Length; i++)
{
if (activeWorkStation.basketSlots[i].laundryBasket != null && activeWorkStation.basketSlots[i].laundryBasket.basketView.activeSelf)
{
IEnumerator closingBasketView = activeWorkStation.basketSlots[i].laundryBasket.DisableBasketViewCoroutine();
StartCoroutine(closingBasketView);
while (activeWorkStation.basketSlots[i].laundryBasket.basketView.activeSelf)
{
yield return(null);
}
}
}
if (grabbedObject != null)
{
Release();
}
activeWorkStation = null;
if (exitedTask != null)
{
exitedTask();
}
Locked = false;
backOutCoroutine = null;
gameObject.SetActive(false);
}
public static void AddWorkStations(ToyFab toyFab, ToyFabSettings toyFabSettings, Simulation sim)
{
// Observers
LotOutObserver LotOutObserver = new LotOutObserver(sim, "LotOutObserver");
RewardObserver RewardObserver = new RewardObserver(sim, "RewardObserver", Program.WSWithRLDispatcher);
toyFab.Subscribe(RewardObserver);
// Work stations
foreach (string wc in toyFabSettings.WorkStations)
{
WorkStation workStation = new WorkStation(toyFab, $"WorkCenter_{wc}", toyFabSettings.LotStepsPerWorkStation[wc]);
workStation.DispatcherWarmUp = new FIFODispatcher(workStation, workStation.Name + "_FIFODispatcher");
workStation.Dispatcher = new FIFODispatcher(workStation, workStation.Name + "_FIFODispatcher");
QueueObserver queueObserver = new QueueObserver(sim, $"Queue_{wc}");
workStation.Subscribe(queueObserver);
// Machines
foreach (MachineData m in toyFabSettings.Machines.Where(x => x.WorkStation == wc))
{
Machine machine = new Machine(toyFab, $"{workStation.Name}_Machine{m.Number}", new GammaDistribution(m.MeanServiceTime, Math.Pow(m.COVServiceTime * m.MeanServiceTime, 2)), workStation, m.Number);
//Machine machine = new Machine(toyFab, $"{workStation.Name}_Machine{m.Number}", new NonNegativeNormalDistribution(m.MeanServiceTime, m.COVServiceTime * m.MeanServiceTime), workStation, m.Number);
//Machine machine = new Machine(toyFab, $"{workStation.Name}_Machine{m.Number}", new ExponentialDistribution(1 / m.MeanServiceTime), workStation, m.Number);
machine.Eligibilities = m.Eligibilities;
machine.Subscribe(LotOutObserver);
workStation.Machines.Add(machine);
}
toyFab.AddWorkCenter(workStation.Name, workStation);
}
}
private WorkStation CreateStation(Vector3 position, Quaternion rotation, Vector3 scale)
{
var station = new WorkStation(CreateNetworkObject(Prefab, position, rotation, scale));
Map.Get.WorkStations.Add(station);
return(station);
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="condition">条件</param>
/// <param name="page">数据页</param>
/// <returns>数据页</returns>
public DataPage GetList(WorkStation condition, DataPage page)
{
string sql = null;
List <DataParameter> parameters = new List <DataParameter>();
try
{
sql = this.GetQuerySql(condition, ref parameters);
//分页关键字段及排序
page.KeyName = "PID";
if (string.IsNullOrEmpty(page.SortExpression))
{
page.SortExpression = "WSCODE";
}
using (IDataSession session = AppDataFactory.CreateMainSession())
{
page = session.GetDataPage <WorkStation>(sql, parameters.ToArray(), page);
}
return(page);
}
catch (Exception ex)
{
throw ex;
}
}
public void SetUp()
{
var a = new WorkStation
{
WorkStationCode = "wscd1",
Description = "d",
CitCode = "citcode1",
AlternativeWorkStationCode = "2",
VaxWorkStation = "vax?",
ZoneType = "smt1"
};
var b = new WorkStation
{
WorkStationCode = "wscd2",
Description = "d",
CitCode = "citcode1",
AlternativeWorkStationCode = "2",
VaxWorkStation = "vax?",
ZoneType = "smt1"
};
var workStations = new List <WorkStation> {
a, b
};
this.WorkStationService.Search("citcode1")
.Returns(new SuccessResult <IEnumerable <WorkStation> >(workStations));
this.Response = this.Browser.Get(
"/production/maintenance/work-stations",
with => { with.Header("Accept", "application/json"); with.Query("searchTerm", "citcode1"); }).Result;
}
protected virtual void BasketUpdate()
{
ContainedBasketIndicator basketIndicator = GetComponentInParent <ContainedBasketIndicator>();
if (basketIndicator != null)
{
WorkStation workstation = basketIndicator.GetComponentInParent <WorkStation>();
LaundryBasket laundryB = workstation.basketSlots[basketIndicator.basketSlotIndex].laundryBasket;
if (laundryB != null)
{
basket = laundryB.basket;
}
else if (laundryB == null)
{
basket = null;
}
}
LaundryBasket laundryBasket = GetComponentInParent <LaundryBasket>();
if (laundryBasket != null)
{
basket = laundryBasket.basket;
}
}
public void SetWorkStationInformation(WorkStation Station)
{
for(int i = 0; i < Main.transform.childCount; i++)
{
UnlockedWeapon UW = Main.transform.GetChild(i).GetComponent<UnlockedWeapon>();
if (UW.gameObject.activeInHierarchy == false) continue;
if (Station.CraftingItem.Information.getID() == UW.getItem().Information.getID())
{
if (LastActive != null)
{
LastActive.SetAsDeselect(UnActive);
}
UW.SetAsActive(ActiveColor);
LastActive = UW;
Debug.Log("Ustawiam aktywy kolor");
}
UW.StartCraftButton.onClick.AddListener(() => UW.ChangeCraftItem(Station) );
UW.StartCraftButton.onClick.AddListener(() => Deselect());
UW.StartCraftButton.onClick.AddListener(() => UW.SetAsActive(ActiveColor) );
UW.StartCraftButton.onClick.AddListener(() => setLastActive(UW));
}
}
protected override void OnUpdate(ModelElementBase modelElement)
{
WorkStation workStation = (WorkStation)modelElement;
queueLength.UpdateValue(workStation.Queue.Count);
queueLengthStatistic.Collect(queueLength.PreviousValue, queueLength.Weight);
}
protected void btSave_Click(object sender, EventArgs e)
{
WorkStation info = new WorkStation();
WorkStationBLL bll = null;
try
{
UIBindHelper.BindModelByControls(this.Page, info);
bll = BLLFactory.CreateBLL <WorkStationBLL>();
if (this.hiID.Value == "")
{
bll.Insert(info);
}
else
{
info.CREATEUSER = this.HiCREATEUSER.Value;
info.CREATETIME = DateTime.Parse(this.HiCREATETIME.Value);
info.PID = this.hiID.Value;
bll.Update(info);
}
ClientScript.RegisterStartupScript(this.GetType(), "myjs", "parent.refreshData();parent.closeAppWindow1();", true);
}
catch (Exception ex)
{
throw ex;
}
}
public void ShouldForConwipPreventExcessWipWhenFirstStationIsFaster()
{
WorkProcess process = new WorkProcess(new InfiniteBacklog());
WipTokenPool wipLimit = new WipTokenPool(4);
WorkStation ws1 = new WorkStation(wipLimit);
WorkStation ws2 = new WorkStation(wipLimit);
process.Add(ws1);
process.Add(ws2);
IProbabilityDistribution distribution1 = new DeterministicDistribution(1);
IProbabilityDistribution distribution2 = new DeterministicDistribution(2);
ws1.AddMachine(new Machine(distribution1));
ws2.AddMachine(new Machine(distribution2));
FlowTestHelper.TickAndAssert(process, 1, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(process, 1, 0, 1, 0, 0);
FlowTestHelper.TickAndAssert(process, 1, 1, 1, 0, 0);
FlowTestHelper.TickAndAssert(process, 1, 1, 1, 0, 1);
FlowTestHelper.TickAndAssert(process, 1, 2, 1, 0, 1);
FlowTestHelper.TickAndAssert(process, 1, 2, 1, 0, 2);
FlowTestHelper.TickAndAssert(process, 0, 3, 1, 0, 2);
FlowTestHelper.TickAndAssert(process, 1, 2, 1, 0, 3);
FlowTestHelper.TickAndAssert(process, 0, 3, 1, 0, 3);
List<WorkItem> completed = new List<WorkItem>(process.CompletedWorktems);
Assert.AreEqual(3, completed[0].CycleTime);
Assert.AreEqual(4, completed[1].CycleTime);
Assert.AreEqual(5, completed[2].CycleTime);
}
public void CheckForStation(GameObject creature)
{
bool isStation = false;
WorkStation station = null;
foreach (var solution in Stations)
{
if (((creature.transform.localPosition.x > solution.transform.localPosition.x - PiecePlacementOffset.x) && (creature.transform.localPosition.x < solution.transform.localPosition.x + PiecePlacementOffset.x)) &&
((creature.transform.localPosition.z > solution.transform.localPosition.z - PiecePlacementOffset.y) && (creature.transform.localPosition.z < solution.transform.localPosition.z + PiecePlacementOffset.y)))
{
isStation = true;
station = solution as WorkStation;
if (isStation)
{
break;
}
}
}
if (station != null && isStation)
{
Vector3 newPos = new Vector3(station.transform.position.x, creature.transform.position.y, station.transform.position.z);
creature.transform.position = newPos;
station.SetCreature(creature.GetComponentInChildren <CreatueBehavior>());
selected = null;
}
}
private static bool Prefix(WorkStation __instance, GameObject taker)
{
try
{
if (!__instance.CanTake(taker) || __instance._animationCooldown > 0f)
{
return(false);
}
var player = taker.GetPlayer();
var station = __instance.GetWorkStation();
try
{
Event.Get.Player.InvokePlayerUnonnectWorkstation(player, station, out var allow);
if (!allow)
{
return(false);
}
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-Event: PlayerConnectWorkstation Event failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
}
station.TabletOwner = player;
station.IsTabletConnected = false;
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Item: Disconnect Workstation Tablet failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
}
return(false);
}
public bool CanAssignWorker(WorkStation _station)
{
switch (_station)
{
case WorkStation.None:
return(false);
case WorkStation.Cabin:
return(true);
case WorkStation.Engine:
if (cabin != null && crewCount < CrewCountMax)
{
return(true);
}
break;
case WorkStation.Drill:
if (cabin != null && crewCount < CrewCountMax)
{
return(true);
}
break;
case WorkStation.Spare:
if (cabin != null && crewCount < CrewCountMax)
{
return(true);
}
break;
}
return(false);
}
private static bool Prefix(WorkStation __instance, GameObject taker)
{
try
{
if (!__instance.CanTake(taker) || __instance._animationCooldown > 0f)
{
return(false);
}
DeactivatingWorkstationEventArgs ev = new DeactivatingWorkstationEventArgs(Exiled.API.Features.Player.Get(taker), __instance);
Player.OnDeactivatingWorkstation(ev);
if (ev.IsAllowed)
{
taker.GetComponent <Inventory>().AddNewItem(ItemType.WeaponManagerTablet, -4.65664672E+11f, 0, 0, 0);
__instance.Network_playerConnected = null;
__instance.NetworkisTabletConnected = false;
__instance._animationCooldown = 3.5f;
}
return(false);
}
catch (Exception exception)
{
API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.DeactivatingWorkstation: {exception}\n{exception.StackTrace}");
return(true);
}
}
protected override void OnExperimentEnd(ModelElementBase modelElement)
{
WorkStation ws = (WorkStation)modelElement;
ExperimentWriter?.WriteLine($"{ws.Name},{meanQueueLength.Average()},{stdQueueLength.Average()}");
Console.WriteLine($"Queue length mean: {meanQueueLength.Average()} stdev: {stdQueueLength.Average()} - {ws.Name}");
}
private void BindData()
{
string id = Request.QueryString["id"];
WorkStationBLL bll = null;
WorkStation info = new WorkStation();
try
{
bll = BLLFactory.CreateBLL <WorkStationBLL>();
if (string.IsNullOrEmpty(id) == false)
{
info.PID = id;
info = bll.Get(info);
UIBindHelper.BindForm(this.Page, info);
this.hiID.Value = info.PID;
this.HiCREATEUSER.Value = info.CREATEUSER;
this.HiCREATETIME.Value = info.CREATETIME.ToString();
}
else
{
info = new WorkStation();
}
}
catch (Exception ex)
{
throw ex;
}
}
private void UpdateSelection()
{
float closestAngle = 360f;
WorkStation closestStation = null;
Vector3 playerForward = Vector3.ProjectOnPlane(PlayerManager.Forward, Vector3.up);
for (int i = 0; i < _workStations.Length; ++i)
{
WorkStation station = _workStations[i];
Vector3 fromTo = Vector3.ProjectOnPlane(station.Anchor.position - PlayerManager.Position, Vector3.up);
float angle = Vector3.Angle(fromTo, playerForward);
if (station.SelectionAngle > angle && closestAngle > angle)
{
closestAngle = angle;
closestStation = station;
}
}
if (closestStation != null && closestStation != _selectedStation)
{
UnselectStation();
_selectedStation = closestStation;
_selectedStation.SelectStation();
}
else if (closestStation == null)
{
UnselectStation();
_selectedStation = null;
}
}
private void ButtonDeleteClick(object sender, EventArgs e)
{
CommonCollection <WorkStation> stores = new CommonCollection <WorkStation>();
foreach (ReferenceStatusImageLinkLabel item in _controlItems)
{
stores.Add((WorkStation)item.Tag);
}
CommonDeletingForm cdf = new CommonDeletingForm(typeof(WorkStation), stores);
if (cdf.ShowDialog() == DialogResult.OK)
{
if (cdf.DeletedObjects.Count == 0)
{
return;
}
foreach (BaseEntityObject o in cdf.DeletedObjects)
{
WorkStation s = o as WorkStation;
if (s != null)
{
_itemsollection.Remove(s);
}
}
FillUiElementsFromCollection();
}
}
public async Task <IActionResult> Edit(int id, [Bind("WorkStationId,WorkStationName,Department")] WorkStation workStation)
{
if (id != workStation.WorkStationId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(workStation);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkStationExists(workStation.WorkStationId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(workStation));
}
public Device makeDevice(DeviceType dt)
{
Device d = new Device();
DeviceType dtype = DeviceType.WorkStation;
switch (dt)
{
case DeviceType.WorkStation: d = new WorkStation();
break;
case DeviceType.Printer: d = new Printer();
break;
case DeviceType.Router: d = new Router();
break;
case DeviceType.Switch: d = new Switch();
break;
case DeviceType.Firewall: d = new Firewall();
break;
case DeviceType.Bridge: d = new Bridge();
break;
Default :;
break;
}
return(d);
}
/// <summary>
/// 更新信息
/// </summary>
/// <param name="">信息</param>
/// <returns>更新行数</returns>
public DataResult <int> Update(WorkStation model)
{
DataResult <int> result = new DataResult <int>();
try
{
if (ExistsCode(model))
{
result.Msg = "编号已存在";
result.Result = -1;
return(result);
}
if (ExistsName(model))
{
result.Msg = "名称已存在";
result.Result = -1;
return(result);
}
model.UPDATEUSER = this.LoginUser.UserID;
result.Result = new WorkStationDAL().Update(model);
result.IsSuccess = true;
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 插入信息(单表)
/// </summary>
/// <param name="">信息</param>
/// <returns>插入行数</returns>
public DataResult <int> Insert(WorkStation model)
{
DataResult <int> result = new DataResult <int>();
try
{
//基本信息
model.PID = Guid.NewGuid().ToString();
model.CREATEUSER = this.LoginUser.UserID;
model.CREATETIME = DateTime.Now;
model.UPDATEUSER = model.CREATEUSER;
model.UPDATETIME = model.CREATETIME;
WorkStationDAL cmdDAL = new WorkStationDAL();
if (ExistsCode(model))
{
result.Msg = "编号已存在";
result.Result = -1;
return(result);
}
if (ExistsName(model))
{
result.Msg = "名称已存在";
result.Result = -1;
return(result);
}
result.Result = new WorkStationDAL().Insert(model);
result.IsSuccess = true;
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
private void ReferenceButtonAddDisplayerRequested(object sender, ReferenceEventArgs e)
{
//StoreForm form = new StoreForm(GlobalObjects.CasEnvironment.Operators[0]);
CommonEditorForm form = new CommonEditorForm(new WorkStation
{
Operator = GlobalObjects.CasEnvironment.Operators[0],
OperatorId = GlobalObjects.CasEnvironment.Operators[0].ItemId
});
if (form.ShowDialog() == DialogResult.OK)
{
if (form.CurrentObject as WorkStation == null)
{
e.Cancel = true;
return;
}
WorkStation s = form.CurrentObject as WorkStation;
_itemsollection.Add(s);
FillUiElementsFromCollection();
e.Cancel = true;
//e.TypeOfReflection = ReflectionTypes.DisplayInNew;
//e.DisplayerText = s.Name;
//e.RequestedEntity = new StoreScreen(s);
}
else
{
e.Cancel = true;
}
}
private void SetWorkStationMode(ViewInformation.ViewType type, WorkStation SingleWorkStation)
{
CopyValues Copy = new CopyValues();
switch (type)
{
case ViewInformation.ViewType.CRAFT_VIEW:
GameObject Worker = null;
switch (SingleWorkStation.mode)
{
case global::WorkStation.Mode.TO_SELL:
Copy.CopyScale(SingleWorkStation.transform, WorkStation.transform, transform);
Copy.CopySpriteRender(SingleWorkStation._SpriteRender, WorkStation.GetComponent<SpriteRenderer>());
Copy.CopyBoxCollider2D(SingleWorkStation._boxCollider2D, WorkStation.GetComponent<BoxCollider2D>());
break;
case global::WorkStation.Mode.ACTIVE:
Copy.CopyScale(SingleWorkStation.transform, WorkerObject.transform, transform);
Copy.CopySpriteRender(SingleWorkStation._SpriteRender, WorkerObject.GetComponent<SpriteRenderer>());
Copy.CopyBoxCollider2D(SingleWorkStation._boxCollider2D, WorkerObject.GetComponent<BoxCollider2D>());
break;
}
break;
}
}
public ActionResult DeleteConfirmed(int id)
{
WorkStation workStation = db.WorkStations.Find(id);
db.WorkStations.Remove(workStation);
db.SaveChanges();
return(RedirectToAction("Index"));
}
protected void GridView1_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
int id = (int)GridView1.DataKeys[e.RowIndex].Value;
workStation = dataWorkStation.readWorkStationEDIT(id);
dataWorkStation.deleteWorkStation(id, workStation.IdLab);
Response.Redirect("/CRUDWorkStation.aspx");
}
protected override void OnInitialized(ModelElementBase modelElement)
{
WorkStation workStation = (WorkStation)modelElement;
queueLength.Reset();
queueLengthStatistic.Reset();
queueLength.UpdateValue(workStation.Queue.Count);
}
//Used by:
//SCP-1499
private void OnWaiting()
{
if (PluginClass.Scp1499Config.SpawnWorkbench)
{
var point = workbenchSpawn.Parse();
WorkStation.CreateWorkStation(point.Position, point.Room.GameObject.transform.rotation.eulerAngles, new Vector3(3, 3, 0.1f));
}
}
public static bool IsStationSelected(WorkStation station)
{
if (Instance._selectedStation != null &&
Instance._selectedStation == station)
{
return(true);
}
return(false);
}
private void OnStationSelected(WorkStation station)
{
if (_grabbedIngredient != null)
{
KillTweens();
_grabbedIngredient.transform.transform.parent = station.Anchor;
_objectMoveTween = _grabbedIngredient.transform.DOLocalMove(Vector3.zero, _objectAnimationTime).SetEase(_objectAnimationCurve);
_objectRotateTween = _grabbedIngredient.transform.DOLocalRotate(Quaternion.identity.eulerAngles, _objectAnimationTime).SetEase(_objectAnimationCurve);
}
}
static void Main(string[] args)
{
Console.WriteLine("Please insert a website address to get its IP address:");
string ip = Console.ReadLine();
WorkStation myworkstation = new WorkStation();
Console.WriteLine("The IP Address for {0} is {1}", ip, myworkstation.GetIp(ip));
Console.Read();
}
/// <summary>
/// 判断名称是否存在
/// </summary>
/// <param name="">信息</param>
/// <returns>true:已存在；fasel:不存在。</returns>
public bool ExistsName(WorkStation model)
{
try
{
return(new WorkStationDAL().ExistsName(model));
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 将类转化为字符串
/// </summary>
/// <returns></returns>
public string ClassToStr()
{
Dictionary <string, string> buff = new Dictionary <string, string>();
buff.Add("WorkStation", WorkStation.ToString());
buff.Add("Material", Material);
buff.Add("MaterialNum", MaterialNum.ToString());
buff.Add("MaterialCount", MaterialCount.ToString());
buff.Add("SendTime", string.Format("{0:yyyy-MM-dd HH:mm:ss}", SendTime));
return(All.Class.SSFile.Dictionary2Text(buff));
}
public async Task <IActionResult> Create([Bind("WorkStationId,WorkStationName,Department")] WorkStation workStation)
{
if (ModelState.IsValid)
{
_context.Add(workStation);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(workStation));
}
public void ToggleOn(WorkStation Station , Item item)
{
gameObject.SetActive(true);
Statistic = Station.getStatistic();
Speed.text = Statistic.Speed.ToString();
HitPower.text = Statistic.HitPoints.ToString();
ProgressGoal.text = item.Information.RequireHitPoints.ToString();
this.item = item;
Image.texture = item.image.sprite.texture;
}
public void ShouldForConwipHandleProcessingTimeOfZeroForPooledMachine()
{
WorkProcess process = new WorkProcess(new InfiniteBacklog());
WipTokenPool wipLimit = new WipTokenPool(5);
WorkStation ws1 = new WorkStation(wipLimit);
WorkStation ws2 = new WorkStation(wipLimit);
WorkStation ws3 = new WorkStation(wipLimit);
process.Add(ws1);
process.Add(ws2);
process.Add(ws3);
IProbabilityDistribution distribution1 = new DeterministicDistribution(0);
IProbabilityDistribution distribution2 = new DeterministicDistribution(1);
IProbabilityDistribution distribution3 = new DeterministicDistribution(1);
IProbabilityDistribution distribution4 = new DeterministicDistribution(1);
ResourcePool pool = new ResourcePool(2);
ws1.AddMachine(new Machine(distribution1, pool));
ws1.AddMachine(new Machine(distribution1, pool));
ws1.AddMachine(new Machine(distribution1, pool));
ws1.AddMachine(new Machine(distribution1, pool));
ws1.AddMachine(new Machine(distribution1, pool));
ws2.AddMachine(new Machine(distribution2, pool));
ws2.AddMachine(new Machine(distribution2, pool));
ws2.AddMachine(new Machine(distribution2, pool));
ws2.AddMachine(new Machine(distribution3, pool));
ws2.AddMachine(new Machine(distribution3, pool));
ws3.AddMachine(new Machine(distribution4, pool));
ws3.AddMachine(new Machine(distribution4, pool));
ws3.AddMachine(new Machine(distribution4, pool));
ws3.AddMachine(new Machine(distribution4, pool));
ws3.AddMachine(new Machine(distribution4, pool));
FlowTestHelper.TickAndAssert(process, 2, 0, 0, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(process, 0, 0, 2, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(process, 0, 0, 0, 0, 2, 0, 0);
FlowTestHelper.TickAndAssert(process, 2, 0, 0, 0, 0, 0, 2);
FlowTestHelper.TickAndAssert(process, 0, 0, 2, 0, 0, 0, 2);
FlowTestHelper.TickAndAssert(process, 0, 0, 0, 0, 2, 0, 2);
FlowTestHelper.TickAndAssert(process, 2, 0, 0, 0, 0, 0, 4);
}
public void ShouldForKanbanRunTwoStationDeterministicMachineWorkProcessAndLastWorkStationWithTwoMachines()
{
WorkProcess process = new WorkProcess(new InfiniteBacklog());
WorkStation ws1 = new WorkStation(new WipTokenPool(8));
WorkStation ws2 = new WorkStation(new WipTokenPool(8));
process.Add(ws1);
process.Add(ws2);
IProbabilityDistribution distribution1 = new DeterministicDistribution(1);
IProbabilityDistribution distribution2 = new DeterministicDistribution(2);
ws1.AddMachine(new Machine(distribution1));
ws2.AddMachine(new Machine(distribution2));
ws2.AddMachine(new Machine(distribution2));
FlowTestHelper.TickAndAssert(process, 1, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(process, 1, 0, 1, 0, 0);
FlowTestHelper.TickAndAssert(process, 1, 0, 2, 0, 0);
FlowTestHelper.TickAndAssert(process, 1, 0, 2, 0, 1);
FlowTestHelper.TickAndAssert(process, 1, 0, 2, 0, 2);
FlowTestHelper.TickAndAssert(process, 1, 0, 2, 0, 3);
}
public void ShouldForKanbanRunThreeWorkstationProcess()
{
WorkProcess process = new WorkProcess(new RandomSizeInfiniteBacklog(new DeterministicDistribution(2)));
WorkStation ws1 = new WorkStation(new WipTokenPool(1));
WorkStation ws2 = new WorkStation(new WipTokenPool(3));
WorkStation ws3 = new WorkStation(new WipTokenPool(2)); // Note: Bug in SetWorkstationWipLimit below?
process.Add(ws1);
process.Add(ws2);
process.Add(ws3);
IProbabilityDistribution distribution1 = new DeterministicDistribution(5);
IProbabilityDistribution distribution2 = new DeterministicDistribution(30);
IProbabilityDistribution distribution3 = new DeterministicDistribution(3);
process[0].AddMachine(new Machine(distribution1));
process[1].AddMachine(new Machine(distribution2));
process[1].AddMachine(new Machine(distribution2));
process[1].AddMachine(new Machine(distribution2));
process[2].AddMachine(new Machine(distribution3));
FlowTestHelper.TickAndAssert(process, 1, 0, 0, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(10, process, 1, 0, 1, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(10, process, 1, 0, 2, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(10, process, 1, 0, 3, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(10, process, 0, 1, 3, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(10, process, 0, 1, 3, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(10, process, 0, 1, 3, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(10, process, 1, 0, 3, 0, 1, 0, 0);
FlowTestHelper.TickAndAssert(6, process, 1, 0, 3, 0, 0, 0, 1);
FlowTestHelper.TickAndAssert(4, process, 1, 0, 3, 0, 1, 0, 1);
//FlowTestHelper.TickAndAssert(10, process, 0, 1, 3, 0, 0, 0, 0);
//List<WorkItem> completed = new List<WorkItem>(process.CompletedWorktems);
//Assert.AreEqual(3, completed[0].CycleTime);
//Assert.AreEqual(4, completed[1].CycleTime);
//Assert.AreEqual(5, completed[2].CycleTime);
//Assert.AreEqual(6, completed[3].CycleTime);
//Assert.AreEqual(6, completed[3].CycleTime);
}
public void ShouldForConwipRunTwoStationSingleDeterministicMachineWorkProcess()
{
WorkProcess process = new WorkProcess(new InfiniteBacklog());
WipTokenPool wipLimit = new WipTokenPool(8);
WorkStation ws1 = new WorkStation(wipLimit);
WorkStation ws2 = new WorkStation(wipLimit);
process.Add(ws1);
process.Add(ws2);
IProbabilityDistribution distribution1 = new DeterministicDistribution(1);
IProbabilityDistribution distribution2 = new DeterministicDistribution(2);
ws1.AddMachine(new Machine(distribution1));
ws2.AddMachine(new Machine(distribution2));
FlowTestHelper.TickAndAssert(process, 1, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(process, 1, 0, 1, 0, 0);
FlowTestHelper.TickAndAssert(process, 1, 1, 1, 0, 0);
FlowTestHelper.TickAndAssert(process, 1, 1, 1, 0, 1);
FlowTestHelper.TickAndAssert(process, 1, 2, 1, 0, 1);
FlowTestHelper.TickAndAssert(process, 1, 2, 1, 0, 2);
}
public void ShouldForKanbanRunTwoStationSingleDeterministicMachineWorkProcess()
{
WorkProcess process = new WorkProcess(new InfiniteBacklog());
WorkStation ws1 = new WorkStation(new WipTokenPool(4));
WorkStation ws2 = new WorkStation(new WipTokenPool(2)); // Note: Bug in SetWorkstationWipLimit below?
process.Add(ws1);
process.Add(ws2);
IProbabilityDistribution distribution1 = new DeterministicDistribution(1);
IProbabilityDistribution distribution2 = new DeterministicDistribution(2);
ws1.AddMachine(new Machine(distribution1));
ws2.AddMachine(new Machine(distribution2));
FlowTestHelper.TickAndAssert(process, 1, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(process, 1, 0, 1, 0, 0);
FlowTestHelper.TickAndAssert(process, 1, 1, 1, 0, 0);
FlowTestHelper.TickAndAssert(process, 1, 1, 1, 0, 1);
FlowTestHelper.TickAndAssert(process, 1, 2, 1, 0, 1);
FlowTestHelper.TickAndAssert(process, 1, 2, 1, 0, 2);
}
public void ShouldRunSingleStationSingleDeterministicMachine()
{
WorkProcess process = new WorkProcess(new InfiniteBacklog());
WorkStation ws1 = new WorkStation(new WipTokenPool(4));
process.Add(ws1);
IProbabilityDistribution distribution1 = new DeterministicDistribution(1);
ws1.AddMachine(new Machine(distribution1));
FlowTestHelper.TickAndAssert(process, 1, 0, 0);
FlowTestHelper.TickAndAssert(process, 1, 0, 1);
FlowTestHelper.TickAndAssert(process, 1, 0, 2);
FlowTestHelper.TickAndAssert(process, 1, 0, 3);
FlowTestHelper.TickAndAssert(process, 1, 0, 4);
}
public void Add(WorkStation workStation)
{
_addedWorkstations.Add(workStation);
_allWorkstations.Insert(_allWorkstations.Count - 1, workStation);
_resourcePools.AddMany(workStation.ResourcePools);
}
public void ShouldForConwipRunPooledMachines()
{
WorkProcess process = new WorkProcess(new InfiniteBacklog());
WipTokenPool wipLimit = new WipTokenPool(8);
WorkStation ws1 = new WorkStation(wipLimit);
WorkStation ws2 = new WorkStation(wipLimit);
process.Add(ws1);
process.Add(ws2);
IProbabilityDistribution distribution1 = new DeterministicDistribution(4);
IProbabilityDistribution distribution2 = new DeterministicDistribution(4);
ResourcePool pool = new ResourcePool(3);
ws1.AddMachine(new Machine(distribution1, pool));
ws1.AddMachine(new Machine(distribution1, pool));
ws1.AddMachine(new Machine(distribution1, pool));
ws2.AddMachine(new Machine(distribution2, pool));
ws2.AddMachine(new Machine(distribution2, pool));
ws2.AddMachine(new Machine(distribution2, pool));
FlowTestHelper.TickAndAssert(process, 3, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(process, 3, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(process, 3, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(process, 3, 0, 0, 0, 0);
FlowTestHelper.TickAndAssert(process, 0, 0, 3, 0, 0);
FlowTestHelper.TickAndAssert(process, 0, 0, 3, 0, 0);
FlowTestHelper.TickAndAssert(process, 0, 0, 3, 0, 0);
FlowTestHelper.TickAndAssert(process, 0, 0, 3, 0, 0);
FlowTestHelper.TickAndAssert(process, 3, 0, 0, 0, 3);
}
public void ChangeCraftItem(WorkStation Station)
{
Station.CraftingItem = item;
Debug.Log("item name:" + item.name);
}
