public void Init(Hashtable changeStateData)
{
_gameMode = GameMode.COMBAT;
_playerCombatSystem = _diContainer.Resolve<PlayerCombatSystem>();
_buildSystem = _diContainer.Resolve<BuildingSystem>();
_inventorySystem = _diContainer.Resolve<InventorySystem>();
_enemySystem = _diContainer.Resolve<EnemySystem>();
_lootSystem = _diContainer.Resolve<LootSystem>();
_particleGod = _diContainer.Resolve<ParticleGOD>();
_monsterGenerator = _diContainer.Resolve<MonsterGenerator>();
Singleton.instance.audioSystem.GenerateAudioLookupForLevel();
_particleGod.InitParticlePool();
//HUD
_hudController = new HUDController(_gameConfig.playerConfig,_gameConfig.hudConfig);
_hudController.Start(() =>
{
_monsterGenerator.Init(_hudController, _playerCombatSystem);
});
_playerCombatSystem.Init(_hudController);
_buildSystem.Init();
_enemySystem.Init();
_lootSystem.Init();
_inventorySystem.Init();
// Get CombatPlayerView
//_playerCombatSystem.isEnabled = true;
_dispatcher.AddListener(GameplayEventType.DAMAGE_TAKEN, onDamageTaken);
_dispatcher.AddListener(GameplayEventType.GAME_COMPLETE, onGameComplete);
_dispatcher.AddListener(GameplayEventType.GAME_RETRY, onGameRetry);
}
private void LoadMonsters(GameState state)
{
var temp = new List <Monster>();
var generator = new MonsterGenerator();
foreach (var dto in state.monsters)
{
var owner = LoadedPlayers.Find(x => x.Name == dto.Owner);
if (dto.Name == "Wizard")
{
dto.Name = "Wizard" + owner.Name.Substring(owner.Name.Length - 1);
}
var monsterFromDTO = generator.GetMonsterByName(dto.Name, owner);
monsterFromDTO.Moves = dto.Moves;
monsterFromDTO.MagicResistance = dto.MagicResistance;
monsterFromDTO.MovesRemaining = dto.MovesRemaining;
monsterFromDTO.Attack = dto.Attack;
monsterFromDTO.Health = dto.Health;
monsterFromDTO.MaxHealth = dto.MaxHealth;
monsterFromDTO.coordinates = dto.Coordinates;
LoadedMonsters.Add(monsterFromDTO);
}
}
public static void AddMonsterMgr(MonsterGenerator mgm)
{
if (!allMonsters.Contains(mgm))
{
allMonsters.Add(mgm);
}
}
/// <summary>
/// Make a chance to place 1 to 4 monsters in every room except the starting room with the player.
/// </summary>
private void PlaceMonsters()
{
if (GameData.Data.CurrentLevel == GameData.Data.Levels - 1)
{
GenerateBeholder();
}
foreach (var segment in map.segments)
{
if (segment.x == playerXsegment && segment.y == playerYsegment)
{
continue;
}
if (Dice.Roll("1D10") <= 8) // Each seggment has a 70% chance of having monsters
{
var numberOfMonsters = Dice.Roll("1D4"); // Generate between 1 and 4 monsters
for (int i = 1; i < numberOfMonsters; i++) // Not starting at zero. Player is in room zero.
{
Point randomRoomLocation = map.GetRandomWalkableLocationInRoom(segment.BBox); // Find a random walkable location in the room to place the monster
if (randomRoomLocation != Point.Zero) // It's possible that the room doesn't have space to place a monster
{ // In that case skip creating the monster
var monster = MonsterGenerator.GetDepthAppropriateMonster(game, GameData.Data.Difficulty); // Temporarily hard code this monster to be created at level 1
monster.X = randomRoomLocation.X;
monster.Y = randomRoomLocation.Y;
map.AddMonster(monster);
}
}
}
}
}
public Dungeon
(
Logger logger,
ItemController itemController,
LadderGenerator ladderGenerator,
MonsterController monsterController,
ItemGenerator itemGenerator,
MonsterGenerator monsterGenerator,
GameObject tile,
int dungeonX,
int dungeonY,
int maxRoomSize,
int minRoomSize,
int maxRooms,
int dungeonLevel
)
{
this.Logger = logger;
this.ItemController = itemController;
this.LadderGenerator = ladderGenerator;
this.MonsterController = monsterController;
this.ItemGenerator = itemGenerator;
this.MonsterGenerator = monsterGenerator;
this.Tile = tile;
this.DungeonX = dungeonX;
this.DungeonY = dungeonY;
this.MaxRoomSize = maxRoomSize;
this.MinRoomSize = minRoomSize;
this.MaxRooms = maxRooms;
this.DungeonLevel = dungeonLevel;
}
public void GenerateNewMonster()
{
Position monsterPosition = SelectRandomWalkableTile(false);
var newMonster = MonsterGenerator.GenerateMonster(0, monsterPosition);
_monsters.Add(newMonster);
}
public PrefabGeneratorWindow()
{
mMonsterGenerator = new MonsterGenerator();
mMonsterGenerator.Init(ANIMATION_PATH, ANIMATOR_CONTROLLER_PATH, PREFAB_PATH);
mPlayerGenerator = new PlayerGenerator();
mPlayerGenerator.Init(ANIMATION_PATH, ANIMATOR_CONTROLLER_PATH, PREFAB_PATH);
mTerrainGenerator = new TerrainGenerator();
mTerrainGenerator.Init(ANIMATION_PATH, ANIMATOR_CONTROLLER_PATH, PREFAB_PATH);
}
private void Start()
{
LoadGameData();
Game.IsTransitioning = false;
Game.GameManager = this;
InitializeTrack();
InitializePlayer();
InitializeIntroduction();
_coinGenerator = gameObject.AddComponent <CoinGenerator>();
_bulletGenerator = gameObject.AddComponent <BulletGenerator>();
_monsterGenerator = gameObject.AddComponent <MonsterGenerator>();
}
private void GenerateMonsters()
{
int enemies = dungeonConstants.NumberOfMonsters;
MonsterGenerator monsterGenerator = new MonsterGenerator(dungeonConstants);
for (int i = 0; i < enemies; i++)
{
MonsterHolder monsterHolder = monsterGenerator.CreateMonsters();
monsterHolder.Deactivate();
dungeon.AddMonster(monsterHolder);
}
}
public MonsterState(MonsterGenerator generator, LevelConfig.LevelDef levelDef, HUDController hudController) : base(generator, levelDef)
{
_currentWaveIndex = 0;
_hudController = hudController;
_waveQueue = new Queue <LevelConfig.WaveDef>();
_maxWaves = levelDef.waves.Length;
for (int i = 0; i < _maxWaves; i++)
{
LevelConfig.WaveDef def = levelDef.waves[i];
def.waveIndex = i;
_waveQueue.Enqueue(def);
}
}
public async UniTask BegineAsync(int currentStage)
{
//モンスターの生成
var monsters = MonsterGenerator.GenerateTwoMonster(currentStage + 1);
//モンスターと戦った時のシミュレーション
var rightSim = BattleSystem.Simulate(playerStatus, monsters.right);
var leftSim = BattleSystem.Simulate(playerStatus, monsters.left);
userInterface.UpdatePlayerStatus(playerStatus);
userInterface.UpdateTwoMonsters(rightSim, leftSim);
BattleSystem.OutBattle outBattle = new BattleSystem.OutBattle();
while (true)
{
var input = await userInterface.WaitInputAsync();
if (input.category == 0)//モンスターとのバトル
{
if (input.pickedThing == 0)
{
outBattle = BattleSystem.Battle(rightSim, itemManager, playerStatus);
}
else if (input.pickedThing == 1)
{
outBattle = BattleSystem.Battle(leftSim, itemManager, playerStatus);
}
else
{
Debug.LogError("誤った選択肢が選ばれています");
}
userInterface.UpdatePlayerStatus(playerStatus);
break;
}
else if (input.category == 1)//アイテム使用
{
itemManager.UseItem((ItemType)input.pickedThing);
rightSim = BattleSystem.Simulate(playerStatus, monsters.right);
leftSim = BattleSystem.Simulate(playerStatus, monsters.left);
userInterface.UpdatePlayerStatus(playerStatus);
userInterface.UpdateTwoMonsters(rightSim, leftSim);//いらなくなるかも
continue;
}
}
await userInterface.BattleExplainAsync(outBattle);
}
// Start is called before the first frame update
void Start()
{
sound = gameObject.AddComponent <AudioSource>();
effect = gameObject.AddComponent <AudioSource>();
sound.clip = ThemeMusic;
sound.volume = 0.5f;
sound.loop = true;
sound.playOnAwake = true;
sound.Play();
GameSessionTime = GameSessionTime * 1.01f;
monsterGenerator = Monsters.GetComponent <MonsterGenerator>();
startGeneratingMonsters = StartGeneratingMonsters();
sessionTimer = SessionTimer();
StartGame();
}
private void GenerateDungeonFeatures(int direction)
{
// Generate architecture for each tree quad recursively
ArchitectureGenerator architecture = new ArchitectureGenerator();
architecture.GenerateArchitecture(dungeonGenerator.quadTree);
// Generate stairs
StairGenerator stairs = new StairGenerator();
stairs.Generate();
// If we cannot solve the level, we need to generate a different one
if (!LevelIsSolvable())
{
Debug.LogError("Dungeon level cannot be solved. Genrating again...");
GenerateDungeon(direction);
return;
}
// Generate player
PlayerGenerator player = new PlayerGenerator();
Stair stair = direction == -1 ? grid.stairDown : grid.stairUp;
player.GenerateAtPos(stair.x, stair.y);
// Generate furniture
FurnitureGenerator furniture = new FurnitureGenerator();
furniture.Generate();
// Generate monsters
MonsterGenerator monsters = new MonsterGenerator();
monsters.Generate();
//monsters.GenerateSingle();
// Generate chests
ChestGenerator chests = new ChestGenerator();
chests.Generate();
// Generate items
ItemGenerator items = new ItemGenerator();
items.Generate();
}
private void GenerateBeholder()
{
Monster[] beholder = MonsterGenerator.CreateBeholder(game, GameData.Data.Difficulty);
Point p = map.GetBeholderLocationInMap();
for (int y = p.Y, row = 0; y < p.Y + 3; y++, row++)
{
for (int x = p.X, col = 0; x < p.X + 3; x++, col++)
{
int index = col + (row * 3);
beholder[index].X = x;
beholder[index].Y = y;
map.AddMonster(beholder[index]);
}
}
game.beholder = beholder;
}
public void Update(float monsterhealth)
{
if (monsterhealth > 0)
{
LabelHealth.Content = monsterhealth;
HealthBar.Value = monsterhealth;
}
else
{
// _autoDamager.Wait();
_timer.Stop();
//Dodanie zarobionej kasy z przeciwnika
var killedMonster = MonsterList.Single(x => x.Id == _currentMonsterId);
var currentMoney = int.Parse(_moneyLabel.Content.ToString());
currentMoney += killedMonster.Money;
_moneyLabel.Content = currentMoney;
//Remove monster from the list
MonsterList.RemoveAt(0);
MonsterGenerator.GenerateNewMonster();
//Załaduj nowego przeciwnika.
var monster = MonsterList.Single(x => x.Id == _currentMonsterId + 1);
_currentMonsterId = monster.Id;
LabelMonsterName.Content = monster.Name + " Lvl " + monster.Level;
LabelHealth.Content = monster.Health;
HealthBar.Maximum = monster.Health;
HealthBar.Value = monster.Health;
//TODO: Napraw crasha, który powstaje kiedy monster nie ma imagepath.
Uri uri = new Uri(monster.ImagePath, UriKind.Relative);
ImageSource imgSource = new BitmapImage(uri);
_monsterImage.Source = imgSource;
//_autoDamager.Start(monster.Health);
_timer.Start();
}
}
protected virtual void RegisterMonsterGeneratorRandomSource(IServiceCollection serviceRegistry)
{
serviceRegistry.AddSingleton <IMonsterGenerator, MonsterGenerator>(serviceProvider =>
{
var schemeService = serviceProvider.GetRequiredService <ISchemeService>();
var monsterFactory = serviceProvider.GetRequiredService <IMonsterPersonFactory>();
var randomSource = serviceProvider.GetRequiredService <IMonsterGeneratorRandomSource>();
var actorTaskSource =
serviceProvider.GetRequiredService <MonsterBotActorTaskSource <ISectorTaskSourceContext> >();
var generator = new MonsterGenerator(schemeService, monsterFactory, randomSource, actorTaskSource);
return(generator);
});
serviceRegistry.AddSingleton <IMonsterPersonFactory, MonsterPersonFactory>(serviceProvider =>
{
var identifierGenerator = serviceProvider.GetService <IMonsterIdentifierGenerator>();
return(new MonsterPersonFactory
{
MonsterIdentifierGenerator = identifierGenerator
});
});
serviceRegistry.AddSingleton <IMonsterGeneratorRandomSource, MonsterGeneratorRandomSource>();
}
public EndState(MonsterGenerator generator, LevelConfig.LevelDef levelDef) : base(generator, levelDef)
{
}
// Called by monster gen to record new kill
public void addKill(MonsterGenerator.MonsterTypes type)
{
if(sectorChallenge == GameEngine.MonsterChallenges.KILL_TIME) {
// Add kill and start timer if needed
GameModeData.KillTimeModeData killTimeData = (GameModeData.KillTimeModeData)gameData;
killTimeData.addKill((int)type);
if(!killTimeData.startTimer)
killTimeData.startTimer = true;
}
else if(sectorChallenge == GameEngine.MonsterChallenges.KILL_NO_DAMAGE) {
// Just add kill
GameModeData.KillNoDamageModeData noDamage = (GameModeData.KillNoDamageModeData)gameData;
noDamage.addKill((int)type);
}
}
void Start()
{
playercontroller = player.GetComponent<PlayerController> ();
monsterGenerator = this.GetComponent<MonsterGenerator> ();
monsterGenerator.setSpawnPoints (spawnPoints);
monsterGenerator.parentSector = this;
treasureFound = false;
// Construct and set goals
switch (sectorChallenge) {
case GameEngine.MonsterChallenges.KILL_TIME:
gameData = new GameModeData.KillTimeModeData();
/******* SET THE GOALS HERE *******/
((GameModeData.KillTimeModeData)gameData).setKills(new int[] { 5, 5, 0, 2, 0});
((GameModeData.KillTimeModeData)gameData).setTime(60f);
break;
case GameEngine.MonsterChallenges.KILL_NO_DAMAGE:
gameData = new GameModeData.KillNoDamageModeData();
/******* SET THE GOALS HERE *******/
((GameModeData.KillNoDamageModeData)gameData).setKills(new int[] {4, 3, 2, 0, 0});
break;
}
// Set texts to blank
timerText.text = "";
if (this.gameObject.name == "Sector1Engine") {
puzzleText.text = "X";
puzzle_count = 3;
}
else {
puzzleText.text = "X";
puzzle_count = 4;
}
for (int i = 0; i < enemyTexts.Length; ++i)
enemyTexts [i].text = "X";
gameData.parentEngine = this;
}
public FlowState(MonsterGenerator generator, LevelConfig.LevelDef levelDef)
{
_generator = generator;
_levelDef = levelDef;
}
private static void OnGameSceneActive()
{
if (CurrentSceneState == SceneState.Game)
{
return;
}
if (GameNoteControllerAwakePatch.colorSuckers == null)
{
GameNoteControllerAwakePatch.colorSuckers = new List <ColorSucker>();
}
else
{
GameNoteControllerAwakePatch.colorSuckers.Clear();
}
if (config.Value.Enabled && (FightSabersGameplaySetup.instance.ColorSuckerEnabled ||
FightSabersGameplaySetup.instance.NoteShrinkerEnabled ||
FightSabersGameplaySetup.instance.TimeWarperEnabled))
{
config.Value.Enabled = false;
OverlayViewController.instance.fsDisableContainerState = !config.Value.Enabled;
OverlayViewController.instance.experienceContainerState = config.Value.Enabled;
configProvider.Store(config.Value);
}
if (config.Value.Enabled)
{
ScoreSubmission.DisableSubmission("FightSabers");
MonsterGenerator.Create();
QuestManager.instance.LinkGameEventsForActivatedQuests();
}
else if (FightSabersGameplaySetup.instance.ColorSuckerEnabled || FightSabersGameplaySetup.instance.NoteShrinkerEnabled || FightSabersGameplaySetup.instance.TimeWarperEnabled)
{
ScoreSubmission.DisableSubmission("FightSabers");
var go = new GameObject("[FS|ModifierManager]");
var modifierManager = go.AddComponent <ModifierManager>();
var modifiers = new List <Type>();
if (FightSabersGameplaySetup.instance.ColorSuckerEnabled)
{
modifiers.Add(typeof(ColorSucker));
}
if (FightSabersGameplaySetup.instance.NoteShrinkerEnabled)
{
modifiers.Add(typeof(NoteShrinker));
}
if (FightSabersGameplaySetup.instance.TimeWarperEnabled)
{
modifiers.Add(typeof(TimeWarper));
}
modifierManager.modifiers = modifiers.ToArray();
modifierManager.noteShrinkerStrength = FightSabersGameplaySetup.instance.NoteShrinkerStrength;
modifierManager.colorSuckerStrength = FightSabersGameplaySetup.instance.ColorSuckerStrength;
modifierManager.timeWarperStrength = FightSabersGameplaySetup.instance.TimeWarperStrength;
new UnityTask(modifierManager.ConfigureModifiers(0.05f));
var scoreControllerManager = go.AddComponent <ScoreControllerManager>();
scoreControllerManager.BombCut += self => {
modifierManager.ReduceColorSuckerColorness();
};
scoreControllerManager.NoteCut += self => {
modifierManager.ImproveColorSuckerColorness();
};
scoreControllerManager.NoteMissed += self => {
modifierManager.ReduceColorSuckerColorness();
};
}
CurrentSceneState = SceneState.Game;
}
public BetweenWaveState(MonsterGenerator generator, LevelConfig.LevelDef levelDef) : base(generator, levelDef)
{
}
public async System.Threading.Tasks.Task CreateMonsters_AlwaysMaxRarityRolls_MaxHighRarityMonstersAsync()
{
var schemeDict = new Dictionary <string, IMonsterScheme>
{
{ "regular", CreateMonsterScheme("regular") },
{ "rare", CreateMonsterScheme("rare") },
{ "champion", CreateMonsterScheme("champion") }
};
var schemeServiceMock = new Mock <ISchemeService>();
schemeServiceMock.Setup(x => x.GetScheme <IMonsterScheme>(It.IsAny <string>()))
.Returns <string>(sid => schemeDict[sid]);
var schemeService = schemeServiceMock.Object;
var dice = new Dice(3121);
var randomSourceMock = new Mock <MonsterGeneratorRandomSource>(dice).As <IMonsterGeneratorRandomSource>();
randomSourceMock.CallBase = true;
randomSourceMock.Setup(x => x.RollRarity()).Returns(2);
randomSourceMock.Setup(x => x.RollRegionCount(It.IsAny <int>())).Returns(20);
var randomSource = randomSourceMock.Object;
var actorList = new List <IActor>();
var actorManagerMock = new Mock <IActorManager>();
actorManagerMock.Setup(x => x.Add(It.IsAny <IActor>())).Callback <IActor>(a => actorList.Add(a));
actorManagerMock.SetupGet(x => x.Items).Returns(actorList);
var actorManager = actorManagerMock.Object;
var monsterGenerator = new MonsterGenerator(schemeService,
randomSource,
actorManager);
var map = await SquareMapFactory.CreateAsync(20);
var sectorMock = new Mock <ISector>();
var patrolRoutes = new Dictionary <IActor, IPatrolRoute>();
sectorMock.SetupGet(x => x.PatrolRoutes).Returns(patrolRoutes);
var sector = sectorMock.Object;
var monsterRegions = new List <MapRegion> {
new MapRegion(1, map.Nodes.ToArray())
};
var sectorScheme = new TestSectorSubScheme
{
RegularMonsterSids = new[] { "regular" },
RareMonsterSids = new[] { "rare" },
ChampionMonsterSids = new[] { "champion" }
};
// ACT
monsterGenerator.CreateMonsters(sector,
new Mock <IBotPlayer>().Object,
monsterRegions,
sectorScheme);
// ASSERT
var championCount = actorManager.Items.Count(x => ((MonsterPerson)x.Person).Scheme.Sid == "champion");
championCount.Should().Be(1);
var rareCount = actorManager.Items.Count(x => ((MonsterPerson)x.Person).Scheme.Sid == "rare");
rareCount.Should().Be(10);
}
protected override void Awake()
{
base.Awake();
_monsterGenerator = GameObject.Find("Generator").GetComponent <MonsterGenerator>();
}
protected override void Awake()
{
base.Awake();
_monsterGenerator = GameObject.Find("Generator").GetComponent<MonsterGenerator>();
}
public async Task CreateMonsters_AlwaysMaxRarityRolls_MaxHighRarityMonstersAsync()
{
var schemeDict = new Dictionary <string, IMonsterScheme>
{
{ "regular", CreateMonsterScheme("regular") },
{ "rare", CreateMonsterScheme("rare") },
{ "champion", CreateMonsterScheme("champion") }
};
var schemeServiceMock = new Mock <ISchemeService>();
schemeServiceMock.Setup(x => x.GetScheme <IMonsterScheme>(It.IsAny <string>()))
.Returns <string>(sid => schemeDict[sid]);
var schemeService = schemeServiceMock.Object;
var dice = new LinearDice(3121);
var randomSourceMock = new Mock <MonsterGeneratorRandomSource>(dice).As <IMonsterGeneratorRandomSource>();
randomSourceMock.CallBase = true;
randomSourceMock.Setup(x => x.RollRarity()).Returns(2);
randomSourceMock.Setup(x => x.RollRegionCount(It.IsAny <int>(), It.IsAny <int>())).Returns(20);
var randomSource = randomSourceMock.Object;
var actorList = new List <IActor>();
var actorManagerMock = new Mock <IActorManager>();
actorManagerMock.Setup(x => x.Add(It.IsAny <IActor>())).Callback <IActor>(a => actorList.Add(a));
actorManagerMock.SetupGet(x => x.Items).Returns(actorList);
var actorManager = actorManagerMock.Object;
var propContainerManagerMock = new Mock <IStaticObjectManager>();
var propContainerManager = propContainerManagerMock.Object;
propContainerManagerMock.SetupGet(x => x.Items).Returns(Array.Empty <IStaticObject>());
var taskSourceMock = new Mock <IActorTaskSource <ISectorTaskSourceContext> >();
var taskSource = taskSourceMock.Object;
var monsterFactory = new MonsterPersonFactory();
var monsterGenerator = new MonsterGenerator(schemeService,
monsterFactory,
randomSource,
taskSource);
var map = await SquareMapFactory.CreateAsync(20).ConfigureAwait(false);
var sectorMock = new Mock <ISector>();
sectorMock.SetupGet(x => x.ActorManager).Returns(actorManager);
sectorMock.SetupGet(x => x.StaticObjectManager).Returns(propContainerManager);
sectorMock.SetupGet(x => x.Map).Returns(map);
var sector = sectorMock.Object;
var monsterRegions = new List <MapRegion>
{
new MapRegion(1, map.Nodes.ToArray())
};
var sectorScheme = new TestSectorSubScheme
{
RegularMonsterSids = new[] { "regular" },
RareMonsterSids = new[] { "rare" },
ChampionMonsterSids = new[] { "champion" }
};
// ACT
monsterGenerator.CreateMonsters(sector,
monsterRegions,
sectorScheme);
// ASSERT
var championCount = actorManager.Items.Count(x => ((MonsterPerson)x.Person).Scheme.Sid == "champion");
championCount.Should().Be(1);
var rareCount = actorManager.Items.Count(x => ((MonsterPerson)x.Person).Scheme.Sid == "rare");
rareCount.Should().Be(10);
}
private void initGenerators() {
itemGenerator = new VhItemGenerator(new ItemFacade());
monsterGenerator = new MonsterGenerator();
}
public void SetGenerator(MonsterGenerator theGenerator)
{
generator = theGenerator;
}
