protected override GameAction PrepareNextActionOverride(out JobStatus progress)
{
var v = m_location - this.Worker.Location;
if (!this.Worker.Location.IsAdjacentTo(m_location, DirectionSet.PlanarUpDown))
{
progress = JobStatus.Fail;
return null;
}
var action = new MineAction(v.ToDirection(), m_mineActionType);
progress = JobStatus.Ok;
return action;
}
protected override GameAction PrepareNextActionOverride(out JobStatus progress)
{
var v = m_location - this.Worker.Location;
if (!v.IsNormal)
{
progress = JobStatus.Fail;
return null;
}
var action = new MineAction(v.ToDirection(), m_mineActionType);
progress = JobStatus.Ok;
return action;
}
protected override GameAction PrepareNextActionOverride(out JobStatus progress)
{
var v = m_location - this.Worker.Location;
if (!v.IsNormal)
{
progress = JobStatus.Fail;
return(null);
}
var action = new MineAction(v.ToDirection(), m_mineActionType);
progress = JobStatus.Ok;
return(action);
}
private void queueEvent(MineAction a, params object[] args)
{
lock (this.EventQueue)
{
this.EventQueue.Enqueue(new KeyValuePair<MineAction, object[]>(a, args));
}
this.EventHandle.Set();
}
private void doEvent(MineAction ev, object[] args)
{
switch (ev)
{
case MineAction.ACTION_UI_LOAD:
this.view.Invoke(new Action(delegate { this.view.UpdateServerList(this.servers); }));
return;
case MineAction.ACTION_SEND_RAW:
return;
case MineAction.ACTION_EDIT_SERVER:
case MineAction.ACTION_ADD_SERVER:
string name = args[0] as string,
address = args[1] as string,
password = args[2] as string;
int port = (int) args[3];
MineServer s;
if (ev == MineAction.ACTION_EDIT_SERVER) {
var g = (Guid) args[4];
if (!this.servers.ContainsKey(g))
throw new ArgumentException("Got an unknown GUID!", "args");
s = this.servers[g];
s.Name = name;
s.Address = address;
s.RconPassword = password;
s.Port = port;
}
else
s = new MineServer(name, address, port, password, Guid.Empty);
lock (this.servers)
{
if (!this.servers.ContainsKey(s.GUID))
this.servers.Add(s.GUID, s);
}
this.saveServerList();
this.view.Invoke(new Action(delegate { this.view.UpdateServerList(this.servers); }));
return;
case MineAction.ACTION_DELETE_SERVER:
Guid deleteguid = (Guid) args[0];
if (!this.servers.ContainsKey(deleteguid))
throw new ArgumentException("Got an unknown GUID!", "args");
lock (this.servers)
{
this.servers.Remove(deleteguid);
}
this.saveServerList();
this.view.Invoke(new Action(delegate { this.view.UpdateServerList(this.servers); }));
return;
}
}
ActionState ProcessAction(MineAction action)
{
if (this.ActionTicksUsed == 1)
{
this.ActionTotalTicks = GetTicks(SkillID.Mining);
}
if (this.ActionTicksUsed < this.ActionTotalTicks)
{
return(ActionState.Ok);
}
var env = this.Environment;
var p = this.Location + action.Direction;
var report = new MineActionReport(this, p, action.Direction, action.MineActionType);
var td = env.GetTileData(p);
switch (action.MineActionType)
{
case MineActionType.Mine:
{
if (!td.IsMinable)
{
SendFailReport(report, "not mineable");
return(ActionState.Fail);
}
var ds = env.GetPossibleMiningPositioning(p, MineActionType.Mine);
if (ds.Contains(action.Direction) == false)
{
SendFailReport(report, "cannot mine to that direction");
return(ActionState.Fail);
}
env.SetTileData(p, TileData.EmptyTileData);
if (td.ID == TileID.NaturalWall)
{
MaterialInfo material = Materials.GetMaterial(td.MaterialID);
ItemID itemID = ItemID.Undefined;
switch (material.Category)
{
case MaterialCategory.Rock:
itemID = ItemID.Rock;
break;
case MaterialCategory.Mineral:
itemID = ItemID.Ore;
break;
case MaterialCategory.Gem:
itemID = ItemID.UncutGem;
break;
case MaterialCategory.Soil:
break;
default:
throw new Exception();
}
if (itemID != ItemID.Undefined)
{
if (this.World.Random.Next(21) >= GetSkillLevel(SkillID.Mining) / 25 + 10)
{
var builder = new ItemObjectBuilder(itemID, material.ID);
var item = builder.Create(this.World);
item.MoveToMustSucceed(this.Environment, p);
}
}
}
}
break;
case MineActionType.Stairs:
{
if (!td.IsMinable)
{
SendFailReport(report, "not mineable");
return(ActionState.Fail);
}
if (!action.Direction.IsPlanarUpDown())
{
SendFailReport(report, "not PlanarUpDown direction");
return(ActionState.Fail);
}
if (td.ID != TileID.NaturalWall)
{
SendFailReport(report, "not natural wall");
return(ActionState.Fail);
}
// We can always create stairs down, but for other dirs we need access there
// XXX ??? When we cannot move in planar dirs?
if (action.Direction != Direction.Down && !env.CanMoveFrom(this.Location, action.Direction))
{
SendFailReport(report, "cannot reach");
return(ActionState.Fail);
}
td.ID = TileID.Stairs;
env.SetTileData(p, td);
}
break;
default:
throw new Exception();
}
SendReport(report);
return(ActionState.Done);
}
ActionState ProcessAction(MineAction action)
{
if (this.ActionTicksUsed == 1)
this.ActionTotalTicks = GetTicks(SkillID.Mining);
if (this.ActionTicksUsed < this.ActionTotalTicks)
return ActionState.Ok;
var env = this.Environment;
var p = this.Location + action.Direction;
var report = new MineActionReport(this, p, action.Direction, action.MineActionType);
var td = env.GetTileData(p);
switch (action.MineActionType)
{
case MineActionType.Mine:
{
if (!td.IsMinable)
{
SendFailReport(report, "not mineable");
return ActionState.Fail;
}
var ds = env.GetPossibleMiningPositioning(p, MineActionType.Mine);
if (ds.Contains(action.Direction) == false)
{
SendFailReport(report, "cannot mine to that direction");
return ActionState.Fail;
}
env.SetTileData(p, TileData.EmptyTileData);
if (td.ID == TileID.NaturalWall)
{
MaterialInfo material = Materials.GetMaterial(td.MaterialID);
ItemID itemID = ItemID.Undefined;
switch (material.Category)
{
case MaterialCategory.Rock:
itemID = ItemID.Rock;
break;
case MaterialCategory.Mineral:
itemID = ItemID.Ore;
break;
case MaterialCategory.Gem:
itemID = ItemID.UncutGem;
break;
case MaterialCategory.Soil:
break;
default:
throw new Exception();
}
if (itemID != ItemID.Undefined)
{
if (this.World.Random.Next(21) >= GetSkillLevel(SkillID.Mining) / 25 + 10)
{
var builder = new ItemObjectBuilder(itemID, material.ID);
var item = builder.Create(this.World);
item.MoveToMustSucceed(this.Environment, p);
}
}
}
}
break;
case MineActionType.Stairs:
{
if (!td.IsMinable)
{
SendFailReport(report, "not mineable");
return ActionState.Fail;
}
if (!action.Direction.IsPlanarUpDown())
{
SendFailReport(report, "not PlanarUpDown direction");
return ActionState.Fail;
}
if (td.ID != TileID.NaturalWall)
{
SendFailReport(report, "not natural wall");
return ActionState.Fail;
}
// We can always create stairs down, but for other dirs we need access there
// XXX ??? When we cannot move in planar dirs?
if (action.Direction != Direction.Down && !env.CanMoveFrom(this.Location, action.Direction))
{
SendFailReport(report, "cannot reach");
return ActionState.Fail;
}
td.ID = TileID.Stairs;
env.SetTileData(p, td);
}
break;
default:
throw new Exception();
}
SendReport(report);
return ActionState.Done;
}
ActionState ProcessAction(MineAction action)
{
if (this.ActionTicksUsed == 1)
this.ActionTotalTicks = GetTicks(SkillID.Mining);
if (this.ActionTicksUsed < this.ActionTotalTicks)
return ActionState.Ok;
var env = this.Environment;
var p = this.Location + action.Direction;
var report = new MineActionReport(this, p, action.Direction, action.MineActionType);
switch (action.MineActionType)
{
case MineActionType.Mine:
{
var terrain = env.GetTerrain(p);
var id = terrain.ID;
if (!terrain.IsMinable)
{
SendFailReport(report, "not mineable");
return ActionState.Fail;
}
if (!action.Direction.IsPlanar() && action.Direction != Direction.Up)
{
SendFailReport(report, "not planar or up direction");
return ActionState.Fail;
}
// XXX is this necessary for planar dirs? we can always move in those dirs
if (!EnvironmentHelpers.CanMoveFrom(env, this.Location, action.Direction))
{
SendFailReport(report, "cannot reach");
return ActionState.Fail;
}
ItemObject item = null;
if (id == TerrainID.NaturalWall && this.World.Random.Next(21) >= GetSkillLevel(SkillID.Mining) / 25 + 10)
{
ItemID itemID;
MaterialInfo material;
if (env.GetInteriorID(p) == InteriorID.Ore)
{
material = env.GetInteriorMaterial(p);
}
else
{
material = env.GetTerrainMaterial(p);
}
switch (material.Category)
{
case MaterialCategory.Rock:
itemID = ItemID.Rock;
break;
case MaterialCategory.Mineral:
itemID = ItemID.Ore;
break;
case MaterialCategory.Gem:
itemID = ItemID.UncutGem;
break;
default:
throw new Exception();
}
var builder = new ItemObjectBuilder(itemID, material.ID);
item = builder.Create(this.World);
}
var td = new TileData()
{
TerrainID = TerrainID.NaturalFloor,
TerrainMaterialID = env.GetTerrainMaterialID(p),
InteriorID = InteriorID.Empty,
InteriorMaterialID = Dwarrowdelf.MaterialID.Undefined,
Flags = TileFlags.None,
WaterLevel = 0,
};
env.SetTileData(p, td);
if (item != null)
{
var ok = item.MoveTo(this.Environment, p);
if (!ok)
throw new Exception();
}
}
break;
case MineActionType.Stairs:
{
var terrain = env.GetTerrain(p);
var id = terrain.ID;
if (!terrain.IsMinable)
{
SendFailReport(report, "not mineable");
return ActionState.Fail;
}
if (!action.Direction.IsPlanarUpDown())
{
SendFailReport(report, "not PlanarUpDown direction");
return ActionState.Fail;
}
if (id != TerrainID.NaturalWall)
{
SendFailReport(report, "not natural wall");
return ActionState.Fail;
}
// We can always create stairs down, but for other dirs we need access there
// XXX ??? When we cannot move in planar dirs?
if (action.Direction != Direction.Down &&
!EnvironmentHelpers.CanMoveFrom(env, this.Location, action.Direction))
{
SendFailReport(report, "cannot reach");
return ActionState.Fail;
}
var td2 = env.GetTileData(p + Direction.Up);
if (td2.TerrainID == TerrainID.NaturalFloor)
{
td2.TerrainID = TerrainID.StairsDown;
if (td2.InteriorID == InteriorID.Grass)
{
td2.InteriorID = InteriorID.Empty;
td2.InteriorMaterialID = Dwarrowdelf.MaterialID.Undefined;
}
env.SetTileData(p + Direction.Up, td2);
}
var td = new TileData()
{
TerrainID = TerrainID.NaturalFloor,
TerrainMaterialID = env.GetTerrainMaterialID(p),
InteriorID = InteriorID.Stairs,
InteriorMaterialID = env.GetTerrainMaterialID(p),
Flags = TileFlags.None,
WaterLevel = 0,
};
env.SetTileData(p, td);
}
break;
case MineActionType.Channel:
{
if (!action.Direction.IsPlanar())
{
SendFailReport(report, "not planar direction");
return ActionState.Fail;
}
// XXX is this necessary for planar dirs? we can always move in those dirs
if (!EnvironmentHelpers.CanMoveFrom(env, this.Location, action.Direction))
{
SendFailReport(report, "cannot reach");
return ActionState.Fail;
}
var td = env.GetTileData(p);
if (td.IsClear == false)
{
SendFailReport(report, "wrong type of tile");
return ActionState.Fail;
}
if (!env.Contains(p + Direction.Down))
{
SendFailReport(report, "tile not inside map");
return ActionState.Fail;
}
var tdd = env.GetTileData(p + Direction.Down);
bool clearDown;
if (tdd.TerrainID == TerrainID.NaturalWall)
{
clearDown = true;
}
else if (tdd.InteriorID == InteriorID.Empty)
{
clearDown = false;
}
else
{
SendFailReport(report, "tile down not empty");
return ActionState.Fail;
}
td.TerrainID = TerrainID.Empty;
td.TerrainMaterialID = Dwarrowdelf.MaterialID.Undefined;
td.InteriorID = InteriorID.Empty;
td.InteriorMaterialID = Dwarrowdelf.MaterialID.Undefined;
env.SetTileData(p, td);
if (clearDown)
{
tdd.TerrainID = TerrainID.NaturalFloor;
tdd.InteriorID = InteriorID.Empty;
tdd.InteriorMaterialID = Dwarrowdelf.MaterialID.Undefined;
env.SetTileData(p + Direction.Down, tdd);
}
}
break;
default:
throw new Exception();
}
SendReport(report);
return ActionState.Done;
}