public void SendBuildOrders(Queue <BuildOrder> orders)
{
if (Peer.ConnectionCount <= 0)
{
return;
}
while (orders.Count > 0)
{
int toSend = Math.Min(orders.Count, 256);
var msg = CreateMessage(DataMessageType.BuildOrders);
msg.Write((byte)(toSend - 1));
for (int i = 0; i < toSend; i++)
{
BuildOrder order = orders.Dequeue();
msg.Write(order.Position);
msg.Write(order.Tile.ID);
}
if (Peer.ConnectionCount > 0)
{
Peer.SendToAll(msg, NetDeliveryMethod.ReliableUnordered, (int)DataSequenceChannel.Tiles);
}
}
}
public async Task <IActionResult> PutBuildOrder(long id, BuildOrder buildOrder)
{
if (id != buildOrder.Id)
{
return(BadRequest());
}
_context.Entry(buildOrder).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BuildOrderExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public BuildOrder ToBuildOrder()
{
var numMaterials = this.BuildableItem.FixedBuildMaterials.Count;
var filters = new IItemFilter[numMaterials];
for (int idx = 0; idx < numMaterials; ++idx)
{
var itemIDs = this.BuildMaterialsView[idx].ItemIDs.Where(i => i.IsSelected).Select(i => i.Value).ToArray();
var materialIDs = this.BuildMaterialsView[idx].MaterialIDs.Where(i => i.IsSelected).Select(i => i.Value).ToArray();
ItemIDMask im = null;
if (itemIDs.Any())
{
im = new ItemIDMask(itemIDs);
}
MaterialIDMask mim = null;
if (materialIDs.Any())
{
mim = new MaterialIDMask(materialIDs);
}
filters[idx] = new ItemFilter(im, null, mim, null);
}
var bo = new BuildOrder(this.BuildableItem, filters);
return(bo);
}
public void GiveOrderToUnits()
{
if (currentState == HandlerState.Idle)
{
if (playerInput.actions.FindActionMap("Player").FindAction("APressed").ReadValue <float>() >= .5f)
{
orderGiver.GiveOrderWithNonFixedParams(SelectedEnteties.ToArray(), new MoveAttackOrderInitParams(""));
}
else
{
orderGiver.GiveOrderWithNonFixedParams(SelectedEnteties.ToArray(), new GameOrderInitParams(""), true);
}
}
else if (currentState == HandlerState.Ordering)
{
orderGiver.GiveOrderWithNonFixedParams(SelectedEnteties.ToArray(), CurrentOrder);
ReturnToIdleState();
}
else if (currentState == HandlerState.Building)
{
if (builder.CanPlaceFlyingBuilding())
{
BuildOrderVariableParams buildOrderVariableParams =
new BuildOrderVariableParams(builder.flyingBuilding, SelectedEnteties[0].gameObject);
BuildOrder buildOrder = new BuildOrder(buildOrderVariableParams);
SelectedEnteties[0].GiveOrder(buildOrder);
builder.PlaceFlyingBuilding();
ReturnToIdleState();
}
}
}
public void DeleteBuildOrder(int buildOrderId)
{
BuildOrder buildOrder = dbContext.BuildOrder.Find(buildOrderId);
dbContext.BuildOrder.Remove(buildOrder);
dbContext.SaveChanges();
}
public JsonResponse GetUploadBuildDetails()
{
var fileContent = Request.Files[0];
if (fileContent == null || fileContent.ContentLength == 0)
{
return(new JsonResponse(false, "File was not added into request!"));
}
BuildOrderInfo uploadBuild = null;
BuildOrder buildEntity = null;
try
{
using (var inputStream = new StreamReader(fileContent.InputStream))
{
var jsonReader = new JsonTextReader(inputStream);
var ser = new JsonSerializer();
uploadBuild = ser.Deserialize <BuildOrderInfo>(jsonReader);
}
buildEntity = ConvertBuildInfoToDomainModel(uploadBuild);
var response = _service.GetBuildByName(buildEntity.Name);
if (response.Result != null)
{
return(new JsonResponse(false, "Build order with name " + buildEntity.Name + " already exists!"));
}
}
catch (Exception ex)
{
return(new JsonResponse(false, "File format is not valid!"));
}
return(new JsonResponse(buildEntity));
}
public GeneralResponse UpdateBuildOrder(BuildOrder buildOrder)
{
if (buildOrder == null)
{
throw new ApplicationException("Build order was not provided");
}
var response = GetBuildByName(buildOrder.Name);
if (response.Result != null && response.Result.ID != buildOrder.ID && response.Result.Name == buildOrder.Name)
{
throw new ApplicationException("Build order already exists");
}
var idResponse = GetBuildByID(buildOrder.ID);
if (idResponse.Result == null)
{
throw new ApplicationException("Build order with ID " + buildOrder.ID + " does not exists!");
}
_buildOrderRepo.Update(buildOrder);
return(new GeneralResponse());
}
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 TwoOneOneBuildOrder(StrategicMapDetails strategicMapDetails, UnitService unitService)
{
_strategicMapDetails = strategicMapDetails;
_unitService = unitService;
_buildOrder = JsonConvert.DeserializeObject <BuildOrder>(EmbededResourceHelper.Get("Bot.BuildOrders.2-1-1.json"));
_buildOrder.Initialize();
}
public async Task <ActionResult <BuildOrder> > PostBuildOrder(BuildOrder buildOrder)
{
_context.BuildOrders.Add(buildOrder);
await _context.SaveChangesAsync();
//return CreatedAtAction("GetBuildOrder", new { id = buildOrder.Id }, buildOrder);
return(CreatedAtAction(nameof(GetBuildOrder), new { id = buildOrder.Id }, buildOrder));
}
public async Task <BuildOrder> SaveBuildOrder(BuildOrder buildOrder)
{
await dbContext.BuildOrder.AddAsync(buildOrder);
await dbContext.SaveChangesAsync();
return(buildOrder);
}
public DynamicBuildOrder(BuildOrder buildOrderData)
{
Description = buildOrderData.Description;
Title = buildOrderData.Title;
for (int i = 0; i < buildOrderData.Queue.Length; i++)
{
Queue.Add(new QueueItem(buildOrderData.Queue[i]));
}
}
static General()
{
Logger.Info("Loading Build Orders");
buildOrders = BuildOrder.LoadAll();
Logger.Info("Loading Map Knowledge");
var mapData = Map.LoadAll();
Logger.Info("--> Loaded {0} map results", mapData.Count);
}
public static Message GenerateBuildMessage(Computer computer, BuildOrder buildOrder)
{
return(new Message(
computer.Id,
computer.Name,
"Sistema",
chooseBuildMessageTitle(buildOrder.BuildId),
chooseBuildMessageBody(buildOrder.BuildId, computer.Name)
));
}
public JsonResponse DeleteBuildOrder(BuildOrder build)
{
if (User == null || (build.OwnerUserID != User.UserData.ID && !User.UserData.Roles.Contains("Admin")))
{
return(new JsonResponse(false, "Unauthorized delete Build Order is not allowed!"));
}
var result = _service.DeleteBuildOrder(build);
return(new JsonResponse(result));
}
public IActionResult MarkShipped(int buildOrderId)
{
BuildOrder buildOrder = repository.BuildOrders.FirstOrDefault(bo => bo.BuildOrderId == buildOrderId);
if (buildOrder != null)
{
buildOrder.Shipped = true;
repository.SaveBuildOrder(buildOrder);
}
return(RedirectToAction(nameof(List)));
}
public Order Clone()
{
BuildOrder BO = new BuildOrder();
BO.idPlayer = this.idPlayer;
BO.isActive = this.isActive;
BO.workers = this.workers;
BO.building = this.building;
BO.movementOrder = this.movementOrder;
BO.timeCounter = this.timeCounter;
return(BO);
}
public BuildOrder ToBuildOrder()
{
var res = new BuildOrder
{
Description = Description,
Title = Title
};
for (int i = 0; i < Queue.Count; i++)
{
res.Queue[i] = Queue[i].ToQueueTask();
}
return(res);
}
private BuildOrderInfo Convert(BuildOrder buildOrder)
{
var buildInfo = new BuildOrderInfo();
buildInfo.BuildOrderItems = buildOrder.BuildItems;
buildInfo.Description = buildOrder.Description;
buildInfo.Name = buildOrder.Name;
buildInfo.Race = buildOrder.Race;
buildInfo.SC2VersionID = buildOrder.SC2VersionID;
buildInfo.VsRace = buildOrder.VsRace;
buildInfo.AddedDate = buildOrder.AddedDate;
return(buildInfo);
}
void Advance()
{
if (queue.Count <= 0)
{
return;
}
// look at the next thing in queue
BuildOrder next = queue[0];
// if we have enough money for it, submit the build order!
// need to know where the hell to send the message, though!
}
public void Run()
{
BuildOrder buildOrder = new BuildOrder();
string[] projects = new string[] { "a", "b", "c", "d", "e", "f" };
string[,] dependencies = new string[, ]
{
{ "a", "d" },
{ "f", "b" },
{ "b", "d" },
{ "f", "a" },
{ "d", "c" }
};
Project[] projectOrder = buildOrder.FindBuildOrder(projects, dependencies);
}
static void Prefix(ProductionStructure __instance)
{
if (__instance.Faction == __instance.Battle.LocalPlayerFactionId)
{
if (__instance.BuildOrders.Count > 0)
{
BuildOrder buildOrder = __instance.BuildOrders.Peek();
var remainingBuildTimeField = Traverse.Create(buildOrder).Field("_remainingTimeTicks");
var remainingBuildTime = remainingBuildTimeField.GetValue <int>();
if (remainingBuildTime > 0)
{
remainingBuildTimeField.SetValue(1);
}
}
}
}
public ServiceResponse <BuildOrder> GetBuildByID(int id)
{
var request = _buildOrderRepo.GetSearchRequest();
request.Filter.BuildOrderID = id;
request.Filter.IsStrictSearch = true;
var response = _buildOrderRepo.SearchBuildOrders(request);
BuildOrder result = null;
if (response.Items.Count > 0)
{
result = response.Items[0];
}
return(new ServiceResponse <BuildOrder>(result));
}
public IActionResult Checkout(BuildOrder buildOrder)
{
if (cart.Lines.Count() == 0)
{
ModelState.AddModelError("", "Sorry, your cart is empty!");
}
if (ModelState.IsValid)
{
//Now we associate the CartLines with the Order
buildOrder.Lines = cart.Lines.ToArray();
repository.SaveBuildOrder(buildOrder);
return(RedirectToAction(nameof(Completed)));
}
else
{
return(View(buildOrder));
}
}
public int Insert(BuildOrder buildOrder)
{
return((int)ExecuteScalarRead <decimal>("dbo.BuildOrders_Insert", new List <SqlParameter>
{
ParamsHelper.CreateInputParameter("@Name", SqlDbType.NVarChar, buildOrder.Name),
ParamsHelper.CreateInputParameter("@SC2VersionID", SqlDbType.NVarChar, buildOrder.SC2VersionID),
ParamsHelper.CreateInputParameter("@Description", SqlDbType.NVarChar, buildOrder.Description),
ParamsHelper.CreateInputParameter("@Race", SqlDbType.NVarChar, buildOrder.Race),
ParamsHelper.CreateInputParameter("@VsRace", SqlDbType.NVarChar, buildOrder.VsRace),
ParamsHelper.CreateInputParameter("@BuildItems", SqlDbType.NVarChar, string.Join(",", buildOrder.BuildItems)),
ParamsHelper.CreateInputParameter("@OwnerUserID", SqlDbType.Int, buildOrder.OwnerUserID),
ParamsHelper.CreateInputParameter("@AddedDate", SqlDbType.DateTime, buildOrder.AddedDate.ToUniversalTime()),
ParamsHelper.CreateInputParameter("@IsDeleted", SqlDbType.Bit, buildOrder.IsDeleted),
ParamsHelper.CreateInputParameter("@Micro", SqlDbType.Int, buildOrder.MicroRate),
ParamsHelper.CreateInputParameter("@Macro", SqlDbType.Int, buildOrder.MacroRate),
ParamsHelper.CreateInputParameter("@Aggression", SqlDbType.Int, buildOrder.AggressionRate),
ParamsHelper.CreateInputParameter("@Defence", SqlDbType.Int, buildOrder.DefenceRate)
}));
}
public ServiceListResponse <BuildOrderItemInfo> GetProcessedBuildItems(BuildOrder build, string versionsFolder)
{
var config = GetConfig(build.SC2VersionID, build.Race, versionsFolder);
var processor = new BuildOrderProcessor(config);
var convertedBuild = ConvertModelToEntity(build);
if (convertedBuild == null)
{
throw new ApplicationException("Cannot convert build order!");
}
processor.LoadBuildOrder(convertedBuild);
var result = GenerateBuildItems(processor.CurrentBuildOrder, config);
return(new ServiceListResponse <BuildOrderItemInfo>(result));
}
private BuildOrderEntity ConvertModelToEntity(BuildOrder build)
{
if (build == null)
{
return(null);
}
var result = new BuildOrderEntity
{
BuildOrderItems = build.BuildItems,
Description = build.Description,
Name = build.Name,
Race = (RaceEnum)Enum.Parse(typeof(RaceEnum), build.Race),
SC2VersionID = build.SC2VersionID,
VsRace = (RaceEnum)Enum.Parse(typeof(RaceEnum), build.VsRace)
};
return(result);
}
public void BuildOderAlgo_WhenThereIsAWayToBuildProjects_ReturnValidBuildOrder()
{
// Arrange
var projects = new string[] { "a", "b", "c", "d", "e", "f" };
var dependencies = new List <Tuple <string, string> >
{
new Tuple <string, string>("a", "d"),
new Tuple <string, string>("f", "b"),
new Tuple <string, string>("b", "d"),
new Tuple <string, string>("f", "a"),
new Tuple <string, string>("d", "c"),
};
// Act
var actual = BuildOrder.BuildOderAlgo(projects, dependencies);
// Assert
actual.Should().NotBeNull();
}
public JsonResponse UploadBuildOrder(string userName)
{
if (User == null || User.UserData.UserName != userName)
{
return(new JsonResponse(false, "Unauthorized build order upload is not allowed!"));
}
var fileContent = Request.Files[0];
if (fileContent == null || fileContent.ContentLength == 0)
{
return(new JsonResponse(false, "File was not added into request!"));
}
BuildOrderInfo uploadBuild = null;
BuildOrder buildEntity = null;
try
{
using (var inputStream = new StreamReader(fileContent.InputStream))
{
var jsonReader = new JsonTextReader(inputStream);
var ser = new JsonSerializer();
uploadBuild = ser.Deserialize <BuildOrderInfo>(jsonReader);
}
buildEntity = ConvertBuildInfoToDomainModel(uploadBuild);
}
catch (Exception ex)
{
return(new JsonResponse(false, "File format is not valid!"));
}
var result = _service.AddBuildOrder(buildEntity);
if (result.Success)
{
Log.Activity(HttpContext, string.Format("New build order [{0}] uploaded by {1}", buildEntity.Name, userName));
}
return(new JsonResponse(result));
}
public GeneralResponse DeleteBuildOrder(BuildOrder buildOrder)
{
if (buildOrder == null)
{
throw new ApplicationException("Build order was not provided");
}
var idResponse = GetBuildByID(buildOrder.ID);
if (idResponse.Result == null)
{
throw new ApplicationException("Build order with ID " + buildOrder.ID + " does not exists!");
}
buildOrder.IsDeleted = true;
_buildOrderRepo.Update(buildOrder);
return(new GeneralResponse());
}
