public BuildOrder CreateBuildOrder(int PlanetID, BuildingTypeIDs BuildingTypeID, int X, int Y)
{
IInsert query;
BuildOrder item;
object result;
LogEnter();
item = new BuildOrder()
{
PlanetID = PlanetID, BuildingTypeID = BuildingTypeID, X = X, Y = Y
};
Log(LogLevels.Information, $"Inserting into Order table ()");
query = new Insert().Into(BotsDB.OrderTable)
.Set(OrderTable.BotID, item.BotID);
result = Try(query).OrThrow <PIODataException>("Failed to insert");
item.OrderID = Convert.ToInt32(result);
Log(LogLevels.Information, $"Inserting into BuildFactoryOrder table (OrderID={item.OrderID}, BuildingTypeID={BuildingTypeID},PlanetID={item.PlanetID}, X={X}, Y={Y})");
query = new Insert().Into(BotsDB.BuildOrderTable)
.Set(BuildOrderTable.OrderID, item.OrderID)
.Set(BuildOrderTable.PlanetID, item.PlanetID)
.Set(BuildOrderTable.X, item.X)
.Set(BuildOrderTable.Y, item.Y)
.Set(BuildOrderTable.BuildingTypeID, item.BuildingTypeID);
result = Try(query).OrThrow <PIODataException>("Failed to insert");
item.BuildOrderID = Convert.ToInt32(result);
return(item);
}
public BuildOrder CreateBuildOrder(int PlanetID, BuildingTypeIDs BuildingTypeID, int X, int Y)
{
BuildOrder[] existingOrders;
BuildOrder buildBuildingOrder;
Building building;
LogEnter();
Log(LogLevels.Information, $"Checking if position is free");
building = Try(() => client.GetBuildingAtPos(PlanetID, X, Y)).OrThrow <PIOInternalErrorException>("Failed to check if position is free");
if (building != null)
{
Log(LogLevels.Warning, $"Position is not free (PlanetID={PlanetID}, X={X}, Y={Y})");
throw new PIOInvalidOperationException($"Position is not free (PlanetID={PlanetID}, X={X}, Y={Y})", null, ID, ModuleName, "CreateBuildFactoryOrder");
}
Log(LogLevels.Information, $"Checking if order already exists (PlanetID={PlanetID}, X={X}, Y={Y})");
existingOrders = Try(() => buildOrderModule.GetBuildOrders(PlanetID, X, Y)).OrThrow <PIOInternalErrorException>("Failed to get ProduceOrder");
if ((existingOrders != null) && (existingOrders.Length > 0))
{
Log(LogLevels.Warning, $"BuildBuilding order already exists (PlanetID={PlanetID}, X={X}, Y={Y})");
throw new PIOInvalidOperationException($"BuildBuilding order already exists (PlanetID={PlanetID}, X={X}, Y={Y})", null, ID, ModuleName, "CreateBuildFactoryOrder");
}
Log(LogLevels.Information, $"Creating BuildFactoryOrder");
buildBuildingOrder = Try(() => buildOrderModule.CreateBuildOrder(PlanetID, BuildingTypeID, X, Y)).OrThrow <PIOInternalErrorException>("Failed to create BuildFactoryOrder");
return(buildBuildingOrder);
}
public Task BeginCreateBuilding(int WorkerID, BuildingTypeIDs BuildingTypeID)
{
Worker worker;
Building building;
Task task;
LogEnter();
worker = AssertExists(() => workerModule.GetWorker(WorkerID), $"WorkerID={WorkerID}");
Log(LogLevels.Information, $"Checking if worker is idle (WorkerID={WorkerID})");
task = Try(() => taskModule.GetLastTask(WorkerID)).OrThrow <PIOInternalErrorException>("Failed to get last task");
if (task != null)
{
Throw <PIOInvalidOperationException>(LogLevels.Warning, $"Worker is not free (WorkerID={WorkerID})");
}
Log(LogLevels.Information, $"Checking if position is free (X={worker.X}, Y={worker.Y})");
building = Try(() => buildingModule.GetBuilding(worker.PlanetID, worker.X, worker.Y)).OrThrow <PIOInternalErrorException>("Failed to get building at position");
if (building != null)
{
Throw <PIOInvalidOperationException>(LogLevels.Warning, $"Current position is not free (X={worker.X}, Y={worker.Y})");
}
Log(LogLevels.Information, $"Creating task (WorkerID={WorkerID})");
task = Try(() => taskModule.CreateTask(TaskTypeIDs.CreateBuilding, WorkerID, worker.X, worker.Y, null, null, BuildingTypeID, DateTime.Now.AddSeconds(10))).OrThrow <PIOInternalErrorException>("Failed to create task");
OnTasksCreated(task);
return(task);
}
public BuildingType GetBuildingType(BuildingTypeIDs BuildingTypeID)
{
if (ThrowException)
{
throw new PIODataException("UnitTestException", null, 1, "UnitTest", "UnitTest");
}
return(items.FirstOrDefault(item => item.BuildingTypeID == BuildingTypeID));
}
public Material[] GetMaterials(BuildingTypeIDs BuildingTypeID)
{
if (throwException)
{
throw new PIODataException("UnitTestException", null, 1, "UnitTest", "UnitTest");
}
return(items.Where(item => item.BuildingTypeID == BuildingTypeID).ToArray());
}
public BuildingType GetBuildingType(BuildingTypeIDs BuildingTypeID)
{
ISelect query;
LogEnter();
Log(LogLevels.Information, $"Querying BuildingType table (BuildingTypeID={BuildingTypeID})");
query = new Select(BuildingTypeTable.BuildingTypeID, BuildingTypeTable.PhraseKey, BuildingTypeTable.HealthPoints, BuildingTypeTable.BuildSteps, BuildingTypeTable.IsFactory, BuildingTypeTable.IsFarm).From(PIODB.BuildingTypeTable).Where(BuildingTypeTable.BuildingTypeID.IsEqualTo(BuildingTypeID));
return(TrySelectFirst <BuildingTypeTable, BuildingType>(query).OrThrow <PIODataException>("Failed to query"));
}
public Ingredient[] GetIngredients(BuildingTypeIDs BuildingTypeID)
{
ISelect query;
LogEnter();
Log(LogLevels.Information, $"Querying Ingredient table (BuildingTypeID={BuildingTypeID})");
query = new Select(IngredientTable.IngredientID, IngredientTable.BuildingTypeID, IngredientTable.ResourceTypeID, IngredientTable.Quantity).From(PIODB.IngredientTable).Where(IngredientTable.BuildingTypeID.IsEqualTo(BuildingTypeID));
return(TrySelectMany <IngredientTable, Ingredient>(query).OrThrow <PIODataException>("Failed to query"));
}
public Task BeginCreateBuilding(int WorkerID, BuildingTypeIDs BuildingTypeID)
{
Task task = new Models.Task()
{
WorkerID = WorkerID, BuildingTypeID = BuildingTypeID
};
TaskCreated(this, new Task[] { task });
return(task);
}
public Material[] GetMaterials(BuildingTypeIDs BuildingTypeID)
{
ISelect query;
LogEnter();
Log(LogLevels.Information, $"Querying Material table (BuildingTypeID={BuildingTypeID})");
query = new Select(MaterialTable.MaterialID, MaterialTable.BuildingTypeID, MaterialTable.ResourceTypeID, MaterialTable.Quantity).From(PIODB.MaterialTable).Where(MaterialTable.BuildingTypeID.IsEqualTo(BuildingTypeID));
return(TrySelectMany <MaterialTable, Material>(query).OrThrow <PIODataException>("Failed to query"));
}
public Product[] GetProducts(BuildingTypeIDs BuildingTypeID)
{
ISelect query;
LogEnter();
Log(LogLevels.Information, $"Querying Product table (BuildingTypeID={BuildingTypeID})");
query = new Select(ProductTable.ProductID, ProductTable.BuildingTypeID, ProductTable.ResourceTypeID, ProductTable.Quantity, ProductTable.Duration).From(PIODB.ProductTable).Where(ProductTable.BuildingTypeID.IsEqualTo(BuildingTypeID));
return(TrySelectMany <ProductTable, Product>(query).OrThrow <PIODataException>("Failed to query"));
}
public Material[] GetMaterials(BuildingTypeIDs BuildingTypeID)
{
if (ThrowException)
{
throw new PIODataException("UnitTestException", null, 1, "UnitTest", "UnitTest");
}
return(Generate((t) => new Material()
{
MaterialID = t, BuildingTypeID = BuildingTypeID
}));
}
public BuildingType GetBuildingType(BuildingTypeIDs BuildingTypeID)
{
if (ThrowException)
{
throw new PIODataException("UnitTestException", null, 1, "UnitTest", "UnitTest");
}
return(new BuildingType()
{
BuildingTypeID = BuildingTypeID
});
}
public Product[] GetProducts(BuildingTypeIDs BuildingTypeID)
{
if (ThrowException)
{
throw new PIODataException("UnitTestException", null, 1, "UnitTest", "UnitTest");
}
return(Generate((t) => new Product()
{
ProductID = t, BuildingTypeID = BuildingTypeID
}));
}
public Ingredient[] GetIngredients(BuildingTypeIDs BuildingTypeID)
{
if (ThrowException)
{
throw new PIODataException("UnitTestException", null, 1, "UnitTest", "UnitTest");
}
return(Generate((t) => new Ingredient()
{
IngredientID = t, BuildingTypeID = BuildingTypeID
}));
}
public Task BeginCreateBuilding(int WorkerID, BuildingTypeIDs BuildingTypeID)
{
if (ThrowException)
{
throw new PIODataException("UnitTestException", null, 1, "UnitTest", "UnitTest");
}
Task task = new Task()
{
WorkerID = WorkerID, ETA = DateTime.Now, BuildingTypeID = BuildingTypeID
};
TaskCreated?.Invoke(this, new Task[] { task });
return(task);
}
/*public Building CreateBuilding(int PlanetID, int X, int Y, int RemainingBuildSteps, BuildingTypeIDs BuildingTypeID)
* {
* Building result;
*
* if (ThrowException) throw new PIODataException("UnitTestException", null, 1, "UnitTest", "UnitTest");
* result = new Building() { BuildingID = items.Count, PlanetID = PlanetID, X = X, Y = Y, RemainingBuildSteps = RemainingBuildSteps, BuildingTypeID = BuildingTypeID };
* items.Add(result);
* return result;
* }*/
public Building CreateBuilding(int PlanetID, int X, int Y, BuildingTypeIDs BuildingTypeID, int RemainingBuildSteps, int HealthPoints)
{
Building result;
if (ThrowException)
{
throw new PIODataException("UnitTestException", null, 1, "UnitTest", "UnitTest");
}
result = new Building()
{
BuildingID = items.Count, PlanetID = PlanetID, X = X, Y = Y
};
items.Add(result);
return(result);
}
public void EndCreateBuilding(int WorkerID, BuildingTypeIDs BuildingTypeID)
{
BuildingType buildingType;
Building building;
Worker worker;
LogEnter();
Log(LogLevels.Information, $"End create building (BuildingTypeID={BuildingTypeID})");
worker = AssertExists(() => workerModule.GetWorker(WorkerID), $"WorkerID={WorkerID}");
buildingType = AssertExists(() => buildingTypeModule.GetBuildingType(BuildingTypeID), $"BuildingTypeID={BuildingTypeID}");
Log(LogLevels.Information, $"Creating building (BuildingTypeID={BuildingTypeID})");
building = Try(() => buildingModule.CreateBuilding(worker.PlanetID, worker.X, worker.Y, BuildingTypeID, buildingType.BuildSteps, buildingType.HealthPoints)).OrThrow <PIOInternalErrorException>("Failed to create factory");
}
public Ingredient CreateIngredient(BuildingTypeIDs BuildingTypeID, ResourceTypeIDs ResourceTypeID, int Quantity)
{
IInsert query;
Ingredient item;
object result;
LogEnter();
item = new Ingredient()
{
BuildingTypeID = BuildingTypeID, ResourceTypeID = ResourceTypeID, Quantity = Quantity,
};
Log(LogLevels.Information, $"Inserting into Ingredient table (BuildingTypeID={BuildingTypeID},ResourceTypeID={ResourceTypeID}, Quantity={Quantity})");
query = new Insert().Into(PIODB.IngredientTable).Set(IngredientTable.BuildingTypeID, item.BuildingTypeID).Set(IngredientTable.ResourceTypeID, item.ResourceTypeID).Set(IngredientTable.Quantity, item.Quantity);
result = Try(query).OrThrow <PIODataException>("Failed to insert");
item.IngredientID = Convert.ToInt32(result);
return(item);
}
public Building CreateBuilding(int PlanetID, int X, int Y, BuildingTypeIDs BuildingTypeID, int RemainingBuildSteps, int HealthPoints)
{
IInsert queryBuilding;
Building item;
object result;
LogEnter();
item = new Building()
{
PlanetID = PlanetID, BuildingTypeID = BuildingTypeID, X = X, Y = Y, RemainingBuildSteps = RemainingBuildSteps, HealthPoints = HealthPoints
};
Log(LogLevels.Information, $"Inserting into Building table (PlanetID={PlanetID}, X={X}, Y={Y}, BuildingTypeID={BuildingTypeID}, RemainingBuildingSteps={RemainingBuildSteps})");
queryBuilding = new Insert().Into(PIODB.BuildingTable).Set(BuildingTable.PlanetID, item.PlanetID).Set(BuildingTable.BuildingTypeID, item.BuildingTypeID).Set(BuildingTable.X, item.X).Set(BuildingTable.Y, item.Y).Set(BuildingTable.HealthPoints, item.HealthPoints).Set(BuildingTable.RemainingBuildSteps, item.RemainingBuildSteps);
result = Try(queryBuilding).OrThrow <PIODataException>("Failed to insert");
item.BuildingID = Convert.ToInt32(result);
return(item);
}
public Product CreateProduct(BuildingTypeIDs BuildingTypeID, ResourceTypeIDs ResourceTypeID, int Quantity, int Duration)
{
IInsert query;
Product item;
object result;
LogEnter();
item = new Product()
{
BuildingTypeID = BuildingTypeID, ResourceTypeID = ResourceTypeID, Quantity = Quantity, Duration = Duration
};
Log(LogLevels.Information, $"Inserting into Product table (BuildingTypeID={BuildingTypeID},ResourceTypeID={ResourceTypeID}, Quantity={Quantity}, Duration={Duration})");
query = new Insert().Into(PIODB.ProductTable).Set(ProductTable.BuildingTypeID, item.BuildingTypeID).Set(ProductTable.ResourceTypeID, item.ResourceTypeID).Set(ProductTable.Quantity, item.Quantity).Set(ProductTable.Duration, item.Duration);
result = Try(query).OrThrow <PIODataException>("Failed to insert");
item.ProductID = Convert.ToInt32(result);
return(item);
}
public BuildingType CreateBuildingType(BuildingTypeIDs BuildingTypeID, string PhraseKey, int BuildSteps, int HealthPoints, bool IsFactory, bool IsFarm)
{
IInsert query;
BuildingType item;
object result;
LogEnter();
item = new BuildingType()
{
BuildingTypeID = BuildingTypeID, PhraseKey = PhraseKey, BuildSteps = BuildSteps, HealthPoints = HealthPoints, IsFactory = IsFactory, IsFarm = IsFarm,
};
Log(LogLevels.Information, $"Inserting into BuildingType table (BuildingTypeID={BuildingTypeID}, PhraseKey={PhraseKey})");
query = new Insert().Into(PIODB.BuildingTypeTable).Set(BuildingTypeTable.BuildingTypeID, item.BuildingTypeID)
.Set(BuildingTypeTable.PhraseKey, item.PhraseKey).Set(BuildingTypeTable.BuildSteps, item.BuildSteps)
.Set(BuildingTypeTable.HealthPoints, item.HealthPoints)
.Set(BuildingTypeTable.IsFactory, item.IsFactory).Set(BuildingTypeTable.IsFarm, item.IsFarm)
;
result = Try(query).OrThrow <PIODataException>("Failed to insert");
//item.BuildingTypeID = Convert.ToInt32(result);
return(item);
}
public BuildOrder CreateBuildOrder(int PlanetID, BuildingTypeIDs BuildingTypeID, int X, int Y)
{
LogEnter();
return(Try(() => orderManagerModule.CreateBuildOrder(PlanetID, BuildingTypeID, X, Y)).OrThrow(GenerateFaultException));
}
public BuildingType CreateBuildingType(BuildingTypeIDs BuildingTypeID, string Name, int BuildSteps, int HealthPoints, bool IsFactory, bool IsFarm)
{
throw new NotImplementedException();
}
public Material CreateMaterial(BuildingTypeIDs BuildingTypeID, ResourceTypeIDs ResourceTypeID, int Quantity)
{
throw new NotImplementedException();
}
public Product[] GetProducts(BuildingTypeIDs BuildingTypeID)
{
LogEnter();
return(Try(() => productModule.GetProducts(BuildingTypeID)).OrThrow(GenerateFaultException));
}
public Ingredient[] GetIngredients(BuildingTypeIDs BuildingTypeID)
{
LogEnter();
return(Try(() => ingredientModule.GetIngredients(BuildingTypeID)).OrThrow(GenerateFaultException));
}
public Task CreateBuilding(int WorkerID, BuildingTypeIDs BuildingTypeID)
{
LogEnter();
return(Try(() => builderModule.BeginCreateBuilding(WorkerID, BuildingTypeID)).OrThrow(GenerateFaultException));
}
public void EndCreateBuilding(int PlanetID, BuildingTypeIDs BuildingTypeID)
{
throw new NotImplementedException();
}
public Ingredient CreateIngredient(BuildingTypeIDs BuildingTypeID, ResourceTypeIDs ResourceTypeID, int Quantity)
{
throw new NotImplementedException();
}
public Product CreateProduct(BuildingTypeIDs BuildingTypeID, ResourceTypeIDs ResourceTypeID, int Quantity, int Duration)
{
throw new NotImplementedException();
}
