// Use this for initialization
private void Awake()
{
/*
* PlayerPrefs.SetFloat("BestTime1000", 0);
* PlayerPrefs.SetFloat("BestTime500", 0);
* PlayerPrefs.SetFloat("BestTime100", 0);
*/
if (PlayerPrefs.GetFloat("BestTime100") == 0)
{
PlayerPrefs.SetFloat("BestTime100", 99 * 60 + 59.999f);
}
if (PlayerPrefs.GetFloat("BestTime500") == 0)
{
PlayerPrefs.SetFloat("BestTime500", 99 * 60 + 59.999f);
}
if (PlayerPrefs.GetFloat("BestTime1000") == 0)
{
PlayerPrefs.SetFloat("BestTime1000", 99 * 60 + 59.999f);
}
if (instance)
{
Destroy(gameObject);
return;
}
instance = this;
}
// Use this for initialization
void Start()
{
score = GameObject.FindGameObjectWithTag("ScoreObject").GetComponent <ScoreClass>();
gameGenerator = GameObject.FindGameObjectWithTag("GameGenerator").GetComponent <GameGenerator>();
isWin = false;
}
public ActionResult Index(GameParameters parameters)
{
var model = new IndexViewModel {
Parameters = parameters
};
if (model.IsValid())
{
var game = new GameGenerator();
var gameGeneratorParameters = MapGameParametersToGameGeneratorParameters(parameters);
var cards = game.GetGameCards(gameGeneratorParameters);
switch (parameters.SortBy)
{
case "Cost":
model.Cards = cards.OrderBy(x => x.Cost).ToList();
break;
case "Name":
model.Cards = cards.OrderBy(x => x.Name).ToList();
break;
case "Set":
model.Cards = cards.OrderBy(x => x.Set).ToList();
break;
default:
model.Cards = cards.ToList();
break;
}
}
return(View(model));
}
private void Awake()
{
rb = GetComponent <Rigidbody2D>();
generator = FindObjectOfType <GameGenerator>();
manager = FindObjectOfType <GameManager>();
}
public SettlementBuilder(GameGenerator gameGen, SettlementBase set)
{
GameGenerator = gameGen;
if (gameGen != null)
{
GenerationRandom = new GenerationRandom(gameGen.Seed);
}
else
{
GenerationRandom = new GenerationRandom(0);
}
BaseChunk = set.BaseChunk;
Centre = set.Centre;
BaseCoord = set.BaseCoord;
SettlementChunks = set.SettlementChunks;
TileSize = set.TileSize;
PathTile = Tile.STONE_PATH;
MidTile = new Vec2i(TileSize / 2, TileSize / 2);
Tiles = new Tile[TileSize, TileSize];
SettlementObjects = new WorldObjectData[TileSize, TileSize];
Buildings = new List <Building>();
//PathNodes = new List<Vec2i>();
BuildingPlots = new List <Recti>();
SettlementType = set.SettlementType;
//TestNodes = new List<SettlementPathNode>();
TestNodes2 = new SettlementPathNode[TileSize / NODE_RES, TileSize / NODE_RES];
//Defines a path node to be once every chunk
PathNodeRes = World.ChunkSize;
PathNodes = new float[TileSize / NODE_RES, TileSize / NODE_RES];
PNSize = TileSize / PathNodeRes;
}
/// <summary>
/// Generates new game from given settings.
/// </summary>
/// <param name="model">Model containing game settings.</param>
/// <returns>Generated game.</returns>
private Game GenerateNewGame(NewGameSettingsModel model)
{
string playerName = model.PlayerName;
Game game;
if (rbRandomMap.IsChecked.HasValue && rbRandomMap.IsChecked.Value == true)
{
int w = model.MapWidth;
int h = model.MapHeight;
int seed = model.MapSeed;
int aiCount = model.AiCount;
double monsterDensity = model.NormalizedMonsterDensity;
double itemDensity = model.NormalizedItemDensity;
game = GameGenerator.GenerateGame(w, h, seed, aiCount, monsterDensity, itemDensity, playerName);
}
else if (rbImportedMap.IsChecked.HasValue && rbImportedMap.IsChecked.Value == true)
{
game = GameGenerator.GenerateGame(model.SelectedImportedMap.Map, playerName);
}
else
{
throw new Exception("Nebyla vybrána žádná volba nastavenà mapy!");
}
return(game);
}
public ActionResult Index(GameParameters parameters)
{
var model = new IndexViewModel { Parameters = parameters };
if (model.IsValid())
{
var game = new GameGenerator();
var gameGeneratorParameters = MapGameParametersToGameGeneratorParameters(parameters);
var cards = game.GetGameCards(gameGeneratorParameters);
switch (parameters.SortBy)
{
case "Cost":
model.Cards = cards.OrderBy(x => x.Cost).ToList();
break;
case "Name":
model.Cards = cards.OrderBy(x => x.Name).ToList();
break;
case "Set":
model.Cards = cards.OrderBy(x => x.Set).ToList();
break;
default:
model.Cards = cards.ToList();
break;
}
}
return View(model);
}
public void GenerateMapFromOptions_Creates_Ok()
{
var gameGenerated = GameGenerator.GenerateMapFromOptions(1, 1,
new SerializableDictionary <ResourcesType, int>()
{
{ ResourcesType.Gold, 5 },
{ ResourcesType.Stone, 5 },
{ ResourcesType.Wood, 5 }
});
// Assert no null values
Assert.IsTrue(gameGenerated is GameDescriptor);
Assert.IsNotNull(gameGenerated.TownHalls);
Assert.IsNotNull(gameGenerated.Carries);
Assert.IsNotNull(gameGenerated.Trees);
Assert.IsNotNull(gameGenerated.GoldMines);
Assert.IsNotNull(gameGenerated.Farms);
Assert.IsNotNull(gameGenerated.Workers);
Assert.IsNotNull(gameGenerated.Resources);
// Assert are values properly populated
Assert.IsTrue(gameGenerated.TownHalls.Count == 1);
Assert.IsTrue(gameGenerated.Carries.Count == 1);
Assert.IsTrue(gameGenerated.Trees.Count == 0);
Assert.IsTrue(gameGenerated.GoldMines.Count == 1);
Assert.IsTrue(gameGenerated.Farms.Count == 1);
Assert.IsTrue(gameGenerated.Workers.Count == 1); // TODO: factoriser le GameGenerator
Assert.IsTrue(gameGenerated.Resources.Count == 3);
Assert.IsTrue(gameGenerated.Resources[ResourcesType.Gold] == 5);
Assert.IsTrue(gameGenerated.Resources[ResourcesType.Stone] == 5);
Assert.IsTrue(gameGenerated.Resources[ResourcesType.Wood] == 5);
}
public MainWindow()
{
// Génère la carte
game = GameGenerator.GenerateDefaultMap();
// Sauvegarde la nouvelle partie dans un fichier
GameFileManager.SaveGame(game, "game1");
// Lit le fichier
game = GameFileManager.ReadGame("game1");
manager = new GameManager(game);
manager.PopulationChanged += OnPopulationChanged;
manager.MaxPopulationChanged += OnMaxPopulationChanged;
manager.BuildingCreated += OnBuildingCreated;
foreach (var carry in game.Carries)
{
carry.CarryStockChanged += OnCarryResourceCollected;
}
InitializeComponent();
this.DataContext = this;
InitializeUIFromGame(game);
}
/// <summary>
/// The main generation function for the whole game
/// Creates a <see cref="GameGenerator"/> and then creates a world using <see cref="GameGenerator.GenerateWorld"/>
/// Then generates all quests using <see cref="GameGenerator.GenerateQuests(World)"/>
/// </summary>
/// <param name="seed">Seed fed to the <see cref="GameGenerator"/> that defines the generation</param>
private void GenerateGame(int seed)
{
//Initiate GameGenerator, then generate and set world
//Debug.BeginDeepProfile("generate_world");
GameGenerator = new GameGenerator(seed);
GameGenerator.GenerateWorld(WorldManager);
GameGenerator.GenerateEntities(WorldManager.World);
GameGenerator.GenerateDungeons();
GameGenerator.GenerateWorldMap();
QuestManager.SetQuests(GameGenerator.GenerateQuests(WorldManager.World));
Vec2i wpos = Vec2i.FromVector2(QuestManager.Unstarted[0].Initiator.GetNPC().Position2);
//Vec2i wpos = WorldManager.World.GetChunkStructure(0).Position * World.ChunkSize + new Vec2i(2, 2);
Vec2i wEntr = WorldManager.World.GetSubworld(1).WorldEntrance;
TestSettle = QuestManager.Unstarted[0].Initiator.GetNPC().NPCKingdomData.GetSettlement();
Debug.Log(TestSettle);
Vec2i playerStartreg = World.GetRegionCoordFromChunkCoord(World.GetChunkPosition(wpos));
ChunkRegionGenerator = GameGenerator.GenerateChunks(playerStartreg);
GeneratePlayer(wpos);
}
// Use this for initialization
void Start()
{
GameGenerator generator = FindObjectOfType <GameGenerator>();
int index = -1;
if (characterTexture)
{
index = label.FindIndex(x => x == generator.generatedCharacter);
if (index != -1)
{
textField.text = "An " + generator.generatedCharacter + " character";
}
}
else
{
index = label.FindIndex(x => x == generator.generatedScene);
if (index != -1)
{
textField.text = "Set at a " + generator.generatedScene;
}
}
if (index >= 0)
{
GetComponent <Image>().sprite = Texture[index];
}
}
public SettlementGenerator(GameGenerator gamGen, World world, Kingdom kingdom, List <SettlementBase> settlements)
{
GameGenerator = gamGen;
Settlements = settlements;
Kingdom = kingdom;
World = world;
}
// Use this for initialization
void Start()
{
GameGenerator generator = FindObjectOfType <GameGenerator>();
int characterToSpawn = 0;
characterToSpawn = System.Math.Max(0, label.FindIndex(x => x == generator.generatedCharacter));
Instantiate(characterPrefabs[characterToSpawn], gameObject.transform.position, Quaternion.Euler(Vector3.zero));
}
public KingdomNPCGenerator(GameGenerator gameGen, Kingdom kingdom, EntityManager entityManager)
{
GameGen = gameGen;
//Create a RNG based on this seed and kingdomID
GenerationRan = new GenerationRandom(GameGen.Seed * 13 + kingdom.KingdomID * 27);
Kingdom = kingdom;
EntityManager = entityManager;
}
public IActionResult Create(GameDescriptorModel gameModel)
{
IGameDescriptor newGameDescriptor = GameGenerator.GenerateMapFromOptions(gameModel.Workers, gameModel.Farms, gameModel.Resources);
gameFileManager.SaveGame(newGameDescriptor, gameModel.Name);
return(Redirect($"/{configuration.GetValue<string>("GameEngine")}?name={gameModel.Name}"));
}
//Initiats the Kingdom generator, the World given is the world the kingdoms will be added to.
public KingdomsGenerator(World world, GameGenerator gameGen)
{
GameGenerator = gameGen;
World = world;
TerrainGenerator = GameGenerator.TerrainGenerator;
KingdomChunks = new Dictionary <Kingdom, List <Vec2i> >(World.ChunkSize * World.ChunkSize / 3);
KingdomSettlements = new Dictionary <Kingdom, List <SettlementBase> >();
GenerationRandom = new GenerationRandom(gameGen.Seed);
}
public void deleteGameGenerator()
{
GameGenerator generator = FindObjectOfType <GameGenerator>();
if (generator)
{
Destroy(generator.gameObject);
}
}
private static async Task Main()
{
Console.WriteLine("Main start");
await PluginGenerator.Save();
await GameGenerator.Save();
Console.WriteLine("Main done");
}
public void Pick10RandomCardsWithNoRules()
{
var game = new GameGenerator();
var parameters = (GameGeneratorParameters.GetInstance());
parameters.FindSet("Dominion").IsSet = true;
parameters.FindSet("Intrigue").IsSet = true;
var cards = game.GetGameCards(parameters);
Assert.AreEqual(10, cards.Count);
}
public DungeonGenerator(GameGenerator gameGen)
{
GameGenerator = gameGen;
GenRan = new GenerationRandom(gameGen.Seed);
BASE_DIRT = new int[World.ChunkSize, World.ChunkSize];
for (int x = 0; x < World.ChunkSize; x++)
{
for (int z = 0; z < World.ChunkSize; z++)
{
BASE_DIRT[x, z] = Tile.DIRT.ID;
}
}
}
public void Pick10RandomCardsThatRequireAReactionCardIfAttackCardPresent()
{
var game = new GameGenerator();
var parameters = GameGeneratorParameters.GetInstance();
parameters.FindSet("Dominion").IsSet = true;
parameters.FindRule("RequireReactionToAttack").IsSet = true;
var cards = game.GetGameCards(parameters);
if (cards.Where(x => x.Type == CardType.Attack).Count() > 0)
Assert.IsTrue(cards.Where(x => x.Type == CardType.Reaction).Count() > 0);
else
Assert.IsTrue(cards.Where(x => x.Type == CardType.Attack).Count() == 0);
}
public void Pick10RandomCardsThatRequiresTwoToFiveCostCards()
{
var game = new GameGenerator();
var parameters = GameGeneratorParameters.GetInstance();
parameters.FindSet("Dominion").IsSet = true;
parameters.FindRule("RequireTwoToFiveCostCards").IsSet = true;
var cards = game.GetGameCards(parameters);
Assert.IsTrue(cards.Where(x => x.Cost == 2).Count() >= 1);
Assert.IsTrue(cards.Where(x => x.Cost == 3).Count() >= 1);
Assert.IsTrue(cards.Where(x => x.Cost == 4).Count() >= 1);
Assert.IsTrue(cards.Where(x => x.Cost == 5).Count() >= 1);
}
public void startLevel()
{
GameGenerator generator = FindObjectOfType <GameGenerator>();
string sceneName = "Game Scene";
// Here the map should be chosen acording to the generated scene.
if (generator.generatedScene != "null")
{
int index = labels.FindIndex(x => x == generator.generatedScene);
sceneName = sceneNames[index];
}
SceneManager.LoadScene(sceneName);
}
// Start is called before the first frame update
void Start()
{
rb = GetComponent <Rigidbody2D>();
tx = 0;
ty = 10000;
player = FindObjectOfType <PlayerController>().transform;
//moving = false;
generator = FindObjectOfType <GameGenerator>();
manager = FindObjectOfType <GameManager>();
Invoke("Generate", 1f);
}
/// <summary>
/// Initiates the ChunkGenerator.
///
/// </summary>
/// <param name="gameGen"></param>
public ChunkGenerator(GameGenerator gameGen)
{
ChunkBases = gameGen.TerrainGenerator.ChunkBases;
Seed = gameGen.Seed;
//Set up default tile arrays
EMPTY_PLAINS = new int[World.ChunkSize, World.ChunkSize];
OCEAN = new int[World.ChunkSize, World.ChunkSize];
EMPTY_DESERT = new int[World.ChunkSize, World.ChunkSize];
for (int x = 0; x < World.ChunkSize; x++)
{
for (int z = 0; z < World.ChunkSize; z++)
{
EMPTY_PLAINS[x, z] = Tile.GRASS.ID;
OCEAN[x, z] = Tile.WATER.ID;
EMPTY_DESERT[x, z] = Tile.SAND.ID;
}
}
}
public static void RunCompetition()
{
System.Console.BackgroundColor = ConsoleColor.Blue;
System.Console.ForegroundColor = ConsoleColor.Yellow;
System.Console.Clear();
System.Console.WriteLine("*** Competition ***");
for (int n = 0; n < 3; ++n)
{
System.Console.WriteLine("Round {0} - Standard Numbers Game with {1} big numbers", (n + 1), n);
for (int t = 0; t < 10; ++t)
{
System.Console.WriteLine("Test {0}", t + 1);
int[] initialNumbers;
int target;
if (GameGenerator.GenerateCountdownGame(n, out initialNumbers, out target))
{
System.Console.Write("Numbers: [");
for (int i = 0; i < initialNumbers.Length; ++i)
{
System.Console.Write("{0}", initialNumbers[i]);
if (i < initialNumbers.Length - 1)
{
System.Console.Write(", ");
}
}
System.Console.WriteLine("]");
System.Console.WriteLine("\r\nTarget: {0}", target);
}
// Now try our solutions
int numSolvers = SolverFactory.RegisteredSolvers;
for (int s = 0; s < numSolvers; ++s)
{
var solver = SolverFactory.CreateSolver(s);
ISolution solution;
if (solver.GetSolution(initialNumbers, target, out solution))
{
}
}
}
}
}
private static Game CreateBaselineGame()
{
var settings = new GameGeneratorSettings
{
GameName = "Baseline",
PlayerNames = { "One", "Two", "Three", },
GalaxySettings = new GalaxyGeneratorSettings
{
GalaxySize = 500,
PlanetCount = 300,
},
};
var generator = new GameGenerator();
return(generator.Generate(settings));
}
public void Pick10RandomCardsWithTwoToFiveCostAndRequireReactionIfAttackCardPresent()
{
var game = new GameGenerator();
var parameters = GameGeneratorParameters.GetInstance();
parameters.FindSet("Dominion").IsSet = true;
parameters.FindRule("RequireTwoToFiveCostCards").IsSet = true;
parameters.FindRule("RequireReactionToAttack").IsSet = true;
var cards = game.GetGameCards(parameters);
if (cards.Where(x => x.Type == CardType.Attack).Count() > 0)
Assert.IsTrue(cards.Where(x => x.Type == CardType.Reaction).Count() > 0);
else
Assert.IsTrue(cards.Where(x => x.Type == CardType.Attack).Count() == 0);
Assert.IsTrue(cards.Where(x => x.Cost == 2).Count() >= 1);
Assert.IsTrue(cards.Where(x => x.Cost == 3).Count() >= 1);
Assert.IsTrue(cards.Where(x => x.Cost == 4).Count() >= 1);
Assert.IsTrue(cards.Where(x => x.Cost == 5).Count() >= 1);
}
void Awake()
{
stackGenerator = new GameStacksBuilder();
prefabsManager = GameObject.FindGameObjectWithTag(Tags.PREFABS_MANAGER).GetComponent <PrefabsManager> ();
int[] chipIds = new int[] { 0, 4, 6, 3, 9, 6 };
int[] crushWeights = new int[] { 0, 0, 5, 4, 0, 0 };
bool[] initFlips = new bool[] { false, true, false, false, true, false };
int[] targetFlips = new int[] { 1, 0, 0 };
GameGeneratorMeta courseMeta = new GameGeneratorMeta(chipIds, crushWeights, initFlips, targetFlips);
ApplicationModel.stackMetaPair = GameGenerator.CreateFromGameGeneratorMeta(courseMeta, prefabsManager);
gamestacks = stackGenerator.BuildGameStacks(ApplicationModel.stackMetaPair, prefabsManager);
gamestacks.Target.gameObject.SetActive(false);
demoStack = gamestacks.Player;
demoStack.AddListener(this);
demoStack.transform.position = new Vector3(0, 0.4f, 0);
demoStack.gameObject.AddComponent(typeof(ChipListHighligter));
}
public void GenerateDefaultMap_Constructor_Ok()
{
var gameGenerated = GameGenerator.GenerateDefaultMap();
// Assert no null values
Assert.IsTrue(gameGenerated is GameDescriptor);
Assert.IsNotNull(gameGenerated.TownHalls);
Assert.IsNotNull(gameGenerated.Carries);
Assert.IsNotNull(gameGenerated.Trees);
Assert.IsNotNull(gameGenerated.GoldMines);
Assert.IsNotNull(gameGenerated.Farms);
Assert.IsNotNull(gameGenerated.Workers);
Assert.IsNotNull(gameGenerated.Resources);
// Assert are values properly populated
Assert.IsTrue(gameGenerated.TownHalls.Count == 1);
Assert.IsTrue(gameGenerated.Carries.Count == 1);
Assert.IsTrue(gameGenerated.Trees.Count == 0);
Assert.IsTrue(gameGenerated.GoldMines.Count == 1);
Assert.IsTrue(gameGenerated.Farms.Count == 2);
Assert.IsTrue(gameGenerated.Workers.Count == 2);
Assert.IsTrue(gameGenerated.Resources.Count == 3);
}
public ChunkRegionGenerator(GameGenerator gameGen, Dictionary <Vec2i, ChunkData> preGenChunks)
{
LOCK_OBJ = new Object();
GameGenerator = gameGen;
CurrentlyThreadGenerating = new List <Vec2i>();
PreGeneratedChunks = preGenChunks;
ChunkGenerator = new ChunkGenerator(gameGen);
RegionsToGen = new List <Vec2i>();
EMPTY_PLAINS = new int[World.ChunkSize, World.ChunkSize];
OCEAN = new int[World.ChunkSize, World.ChunkSize];
for (int x = 0; x < World.ChunkSize; x++)
{
for (int z = 0; z < World.ChunkSize; z++)
{
EMPTY_PLAINS[x, z] = Tile.GRASS.ID;
OCEAN[x, z] = Tile.WATER.ID;
}
}
}
public IActionResult Create()
{
var newGameDescriptor = GameGenerator.GenerateDefaultMap();
// TODO: créer un mapper
// Mapping de GameDescriptor vers GameDescriptorModel
GameDescriptorModel gamedescriptorModel = new GameDescriptorModel
{
Farms = newGameDescriptor.Farms.Count,
Workers = newGameDescriptor.Workers.Count,
};
if (newGameDescriptor.Resources != null)
{
gamedescriptorModel.Resources = new SerializableDictionary <ResourcesType, int>();
foreach (var resource in newGameDescriptor.Resources)
{
gamedescriptorModel.Resources[resource.Key] = resource.Value;
}
}
return(View(gamedescriptorModel));
}
public LakeGenerator(GameGenerator gamGen)
{
GameGenerator = gamGen;
Lakes = new List <Lake>();
}
public ChunkStructureGenerator(GameGenerator gameGen)
{
GameGenerator = gameGen;
GenerationRandom = new GenerationRandom(gameGen.Seed * 13 + 29535);
}
public void GenerateMapFromOptions_ThrowsArgumentNullException_IfResourcesAreNull()
{
GameGenerator.GenerateMapFromOptions(1, 1, null);
}
void Awake()
{
//instance
_gameGeneratorInstance = this;
}
