Example #1
0
            protected override IEnumerable <Task> GetTasks()
            {
                string desc = $"{DescForTool(mineable.tool)} {mineable.def.name}.";

                yield return(new TaskGoTo(game, desc, PathCfg.Adjacent(tile.pos)));

                yield return(new TaskTimedLambda(
                                 game, desc, MinionAnim.Slash,
                                 mineable.tool, mineable.mineAmt,
                                 TaskTimed.FacePt(tile.pos),
                                 _ => 1,
                                 (task, workAmt) =>
                {
                    BB.Assert(task.work == activeWork);
                    mineable.mineAmt -= workAmt;
                    return true;
                },
                                 (task) =>
                {
                    BB.Assert(task.work == activeWork);
                    BB.Assert(mineable.mineAmt <= 0);

                    mineable.jobHandles.Remove(this);
                    game.RemoveBuilding(mineable);
                    game.DropItems(tile, mineable.GetMinedMaterials());
                }
                                 ));
            }
Example #2
0
            private void AddOrder(RecipeDef recipe)
            {
                BB.Assert(bench.proto.def.recipes.Contains(recipe));
                var order = new Order(recipe);

                orders.Add(order);

                var path = PathCfg.Adjacent(bench.bounds);

                order.hauls = new HaulProviders(game, bench.def.name, path,
                                                recipe.materials);
            }
Example #3
0
            private IEnumerable <Task> GetBuildTasks()
            {
                yield return(Capture(new TaskClaim(game,
                                                   (work) => ClaimBuild()), out var buildClaim));

                // TODO: only the builder can clear debris for
                // now to prevent jobs failing immediately after
                // all the debris is claimed
                foreach (var task in GetClearDebrisTasks())
                {
                    yield return(task);
                }

                if (!building.conDef.proto.passable)
                {
                    yield return(new TaskLambda(
                                     game, "init. build",
                                     (work) =>
                    {
                        if (!IsBlocked(work.minion))
                        {
                            building.constructionBegan = true;
                            game.RerouteMinions(area, true);
                            return true;
                        }

                        return false;
                    }));
                }
                yield return(new TaskGoTo(game, $"Building {name}.", PathCfg.Adjacent(area)));

                yield return(new TaskTimedLambda(
                                 game, $"Building {name}.",
                                 MinionAnim.Slash, Tool.Hammer, 2,
                                 TaskTimed.FaceArea(area),
                                 _ => 1, // TODO: workspeed
                                 // TODO: track work amount on building
                                 null,   //(work, workAmt) => /**/, 9
                                 (task) =>
                {
                    BB.Assert(tile.building == building);

                    task.work.Unclaim(buildClaim);
                    hauls.RemoveStored();

                    building.jobHandles.Remove(this);
                    game.ReplaceBuilding(
                        building.conDef.proto.CreateBuilding(tile, building.dir));

                    activeWorks.Remove(task.work);
                    system.RemoveJob(this);
                }));
            }
Example #4
0
            protected override IEnumerable <Task> GetTasks()
            {
                string desc = $"Deconstructing {building.def.name}.";

                yield return(new TaskGoTo(game, desc, PathCfg.Adjacent(building.bounds)));

                yield return(new TaskTimedLambda(
                                 game, desc, MinionAnim.Slash, Tool.Hammer, 2,
                                 TaskTimed.FaceArea(building.bounds),
                                 _ => 1,
                                 null, // TODO: track deconstruct amt
                                 (task) =>
                {
                    BB.Assert(building.tile.building == building);
                    building.jobHandles.Remove(this);
                    game.RemoveBuilding(building);
                    game.DropItems(building.tile, buildable.GetBuildMaterials());
                }));
            }