public ScenarioGame(GodGameOffline offline, TWEngine engine, Internal.Model.World world,
TownCenterType townCenterType, TownCenterService townCenterService,
MinerType minerType)
{
this.world = world;
this.townCenterType = townCenterType;
this.townCenterService = townCenterService;
this.minerType = minerType;
offline.AddSimulatorsToEngine(engine);
int skipFrames = 0;
var scenarioTasks = Run().GetEnumerator();
bool complete = false;
engine.AddSimulator(() =>
{
skipFrames--;
if (skipFrames > 0)
{
return;
}
if (!scenarioTasks.MoveNext())
{
complete = true;
}
if (complete)
{
return;
}
skipFrames = scenarioTasks.Current;
}, "ScenarioSimulator");
}
public static SerializedWorld FromWorld(Internal.Model.World world)
{
var sWorld = new SerializedWorld();
world.ForEach((v, p) => sWorld.Voxels.Add(SerializedVoxel.FromVoxel(v)));
return(sWorld);
}
public static MHGameWork.TheWizards.GodGame.Internal.Model.World createTestWorld(int voxelSize, int size)
{
Internal.Model.World world = null;
world = new MHGameWork.TheWizards.GodGame.Internal.Model.World((w, p) => new GameVoxel(w, p), new ProxyGenerator());
world.Initialize(size, voxelSize);
return(world);
}
public MonumentType(Func <IVoxelHandle, MonumentVoxelBrain> createMonumentVoxel, Internal.Model.World world)
: base("Monument")
{
this.createMonumentVoxel = createMonumentVoxel;
this.world = world;
Color = Color.Green;
}
/*public static GodGameOffline CreateGame()
* {
* var world = new Internal.Model.World(100, 10);
* buildDemoWorld(world);
*
*
*
*
* var ret = new GodGameOffline(EngineFactory.CreateEngine(), world);
*
* return ret;
* }*/
private static void buildDemoWorld(Internal.Model.World world, VoxelTypesFactory typesFactory)
{
world.ForEach((v, p) =>
{
if (Vector2.Distance(p, new Vector2(100, 100)) < 100)
{
v.Data.Type = typesFactory.Get <LandType>();
}
else if (Vector2.Distance(p, new Vector2(8, 8)) < 7)
{
v.Data.Type = typesFactory.Get <LandType>();
}
else if (Vector2.Distance(p, new Vector2(25, 25)) < 15)
{
v.Data.Type = typesFactory.Get <LandType>();
}
//v.ChangeType(GameVoxelType.Infestation);
else
{
v.Data.Type = typesFactory.Get <LandType>();
}
});
/*var worldPersister = new WorldPersister(getTypeFromName, getItemFromName);
* var simpleWorldRenderer = new SimpleWorldRenderer(world);
* var ret = new GodGameOffline(EngineFactory.CreateEngine(),
* world,
* new UserInputProcessingService(createPlayerInputs(world).ToArray(), world, worldPersister, simpleWorldRenderer),
* worldPersister,
* simpleWorldRenderer);
*
* return ret;*/
}
public void ApplyVoxels(Internal.Model.World world, GameplayObjectsSerializer objectSerializer)
{
foreach (var voxel in Voxels)
{
var target = world.GetVoxel(new Point2(voxel.X, voxel.Y));
voxel.ToVoxel(target, objectSerializer);
}
}
public void Setup()
{
world = TestWorldBuilder.createTestWorld(20, 10);
gameState = new GameState(world);
inputHandler = Substitute.For <IPlayerInputHandler>();
npf = new NetworkedPlayerFactory(
(transporter, handler) => new NetworkPlayerInputForwarder(transporter, handler, world),
state => inputHandler, gameState);
}
private void addPersistence(WorldPersisterService persister, Internal.Model.World world)
{
addCommand("save", file =>
{
persister.Save(world, TWDir.GameData.CreateChild("Saves\\GodGame").CreateFile(file + ".xml"));
return("Saved world to " + "Saves\\GodGame\\" + file + ".xml");
});
addCommand("load", file =>
{
persister.Load(world, TWDir.GameData.CreateChild("Saves\\GodGame").CreateFile(file + ".xml"));
return("Loaded world to " + "Saves\\GodGame\\" + file + ".xml");
});
}
public ItemTypesFactory(Internal.Model.World world)
{
this.world = world;
CropType = CreateItemType("Crop", Color.Orange);
FishType = CreateItemType("Fish", Color.DeepSkyBlue);
WoodType = CreateItemType("Wood", Color.SaddleBrown);
PigmentType = CreateItemType("Pigment", Color.DarkViolet);
CrystalType = CreateItemType("Crystal", Color.LightBlue);
StoneType = CreateItemType("Stone", Color.Gray);
rawTypes.ForEach(raw => createKanbanTypes(raw));
}
public void ProcessChanges(Internal.Model.World world)
{
world.ChangedVoxels.ForEach(v =>
{
changedVoxels.OnNext(v);
world.Get8Connected(v.Coord).ForEach(neighbour =>
{
if (changeActions.ContainsKey(neighbour))
{
changeActions[neighbour](v);
}
});
});
}
public void ToWorld(Internal.Model.World world, GameplayObjectsSerializer gameplayObjectsSerializer)
{
foreach (var el in Voxels)
{
var v = world.GetVoxel(new Point2(el.X, el.Y));
if (v == null)
{
//Console.WriteLine("Deserializing voxel but world to small: " + el.X + ", " + el.Y);
continue;
}
try
{
el.ToVoxel(v, gameplayObjectsSerializer);
}
catch (Exception ex)
{
DI.Get <IErrorLogger>().Log(ex, "Can't load voxel in serializedworld");
}
}
}
public void Setup()
{
textarea = new Textarea();
textarea.Text = "";
builder = new Autofac.ContainerBuilder();
foreach (var type in Assembly.GetExecutingAssembly().GetTypes().Where(t => t.Namespace != null && t.Namespace.StartsWith("MHGameWork.TheWizards.GodGame") &&
t.IsPublic))
{
builder.Register(delegate(IComponentContext ctx)
{
textarea.Text += type.FullName + "\n";
return(new object());
}).As(type);
}
world = TestWorldBuilder.createTestWorld(100, 10);
builder.RegisterInstance(world);
builder.RegisterInstance(worldPersister);
builder.Register(ctx => new PlayerTool[0]).As <IEnumerable <PlayerTool> >();
}
public void Setup()
{
var builder = new ContainerBuilder();
builder.RegisterModule <OfflineGameModule>();
builder.RegisterType <Internal.Model.World>().SingleInstance().AsSelf()
.OnActivating(args =>
{
args.Instance.Initialize(10, 10);
var land = args.Context.Resolve <LandType>();
args.Instance.ForEach((v, p) => v.ChangeType(land));
});
var cont = builder.Build();
var offline = cont.Resolve <GodGameOffline>();
offline.AddSimulatorsToEngine(EngineFactory.CreateEngine());
world = offline.World;
types = cont.Resolve <VoxelTypesFactory>();
items = cont.Resolve <ItemTypesFactory>();
basicFactory = new GenericVoxelType <BasicFactory>(v => new BasicFactory(v));
constantFactory = new GenericVoxelType <ConstantFactory>(v => new ConstantFactory(v));
pusher = new GenericVoxelType <Pusher>(v => new Pusher(v));
puller = new GenericVoxelType <Puller>(v => new Puller(v));
v55 = world.GetVoxel(new Point2(5, 5));
v56 = world.GetVoxel(new Point2(5, 6));
v57 = world.GetVoxel(new Point2(5, 7));
v46 = world.GetVoxel(new Point2(4, 6));
v36 = world.GetVoxel(new Point2(3, 6));
}
public AllCommandProvider(WorldPersisterService persister,
Internal.Model.World world,
VoxelTypesFactory typesFactory,
ItemTypesFactory itemTypesFactory,
UserInputProcessingService userInputProcessingService,
GenericDatastore genericDatastore)
{
this.typesFactory = typesFactory;
this.itemTypesFactory = itemTypesFactory;
this.genericDatastore = genericDatastore;
addDummy();
addPersistence(persister, world);
addCommand("clearinfestation", () =>
{
world.ForEach((v, _) =>
{
if (v.Type != typesFactory.Get <InfestationVoxelType>())
{
return;
}
typesFactory.Get <InfestationVoxelType>().CureInfestation(v);
});
return("Cleared all infestation!");
});
addCommand("helpall", () =>
{
return("All Commands: " + string.Join(", ", CommandNames.ToArray()));
});
addCommand("help", partialCommand =>
{
return("Commands containing '" + partialCommand + "': " + string.Join(", ", CommandNames.Where(c => c.Contains(partialCommand)).ToArray()));
});
addCommand("clearWorld", () =>
{
genericDatastore.ClearAll();
world.ForEach((v, _) =>
{
v.Data.Type = typesFactory.Get <LandType>();
});
return("World cleared!");
});
addCommand("listsaves", () =>
{
var saves = TWDir.GameData.CreateChild("Saves\\GodGame").GetFiles().ToList();
var outputstring = String.Join(", ", saves.Select(e => e.Name.Substring(0, e.Name.Length - 4))); // Drop extension
return("Saved games: \n" + outputstring);
});
addCommand("addresource", (typeStr, amountStr) =>
{
var itemType = itemTypesFactory.AllTypes.FirstOrDefault(t => t.Name.ToLower() == typeStr.ToLower());
if (itemType == null)
{
return("Item type not found: " + typeStr);
}
var amount = 0;
if (!int.TryParse(amountStr, out amount))
{
return("Invalid item amount: " + amountStr);
}
var target = userInputProcessingService.GetTargetedVoxel();
if (target == null || target.Type != typesFactory.Get <WarehouseType>())
{
return("Not targeting a warehouse");
}
target.Data.Inventory.AddNewItems(itemType, amount);
return("Added items!");
});
}
public NetworkPlayerInputForwarder(IClientPacketTransporter <UserInputHandlerPacket> transporter, IPlayerInputHandler handler, Internal.Model.World world)
{
this.transporter = transporter;
this.handler = handler;
this.world = world;
}
public GenericDatastore(Internal.Model.World world)
{
this.world = world;
RootRecord = CreateNewRecord();
}
