void resetUnitsInLevel(GenLevel level)
{
foreach (bUnit guy in level.enemyUnits)
{
guy.curHealth = guy.maxHealth;
}
}
public void loadGenLevel(GenLevel level, bool refresh)
{
friendlyBoard = new Slot[level.friendlySlotNum];
enemyBoard = new Slot[level.enemySlotNum];
unitSelectPanel = GameObject.Find("UnitSelectPanel");
Vector3 curSlotPos = countToPos[level.friendlySlotNum];
float slotOffset = countToOffset[level.friendlySlotNum];
for (int i = 0; i < level.friendlySlotNum; i++)
{
GameObject tempSlotObj = Instantiate(friendSlot, curSlotPos, Quaternion.identity);
tempSlotObj.transform.Rotate(new Vector3(270, 0, 0));
friendlyBoard[i] = tempSlotObj.GetComponent <Slot>();
tempSlotObj.GetComponent <Slot>().slotIndex = i;
curSlotPos.x += slotOffset;
}
curSlotPos = countToPos[level.enemySlotNum] + new Vector3(0, .5f, 5);
slotOffset = countToOffset[level.enemySlotNum];
for (int i = 0; i < level.enemySlotNum; i++)
{
GameObject tempSlotObj = Instantiate(enemySlot, curSlotPos, Quaternion.identity);
tempSlotObj.transform.Rotate(new Vector3(270, 0, 0));
enemyBoard[i] = tempSlotObj.GetComponent <Slot>();
tempSlotObj.GetComponent <Slot>().slotIndex = i;
curSlotPos.x += slotOffset;
}
//spawn enemy units based on level
for (int i = 0; i < Mathf.Min(level.enemyUnits.Length, level.enemySlotNum); i++)
{
spawnAtSlot(level.enemyUnits[i], enemyBoard[i]);
/*enemyBoard[i].myUnitMesh.enemyAnimation();*/
enemyBoard[i].myUnitMesh.initAnimation();
enemyUnitCount++;
enemyBoard[i].myUnit.isFriendly = false;
}
//initialize spawn buttons for player
Vector3 buttonTransform = GameObject.Find("ButtonPlacement").transform.position;
ih.initButtons(buttonTransform, unitSelectPanel.transform, spawnButton);
handleBackup(refresh, level.startingCtrl);
curPhase = GamePhase.Prep;
mk.initMarketPhase(null);
}
float chooseEnemiesForCount(GenLevel ret, int numEnemies)
{
float totDifficultyOfBoard = 0;
ret.enemyUnits = new bUnit[numEnemies];
for (int i = 0; i < numEnemies; i++)
{
BaseUnit typeToDeploy = chooseEnemy();
/*GameObject tempUnitObj = Instantiate(gc.basicUnit, new Vector3(100, 100, 100), Quaternion.identity);
* tempUnitObj.GetComponent<Unit>().assignType(typeToDeploy);*/
ret.enemyUnits[i] = new bUnit(typeToDeploy);
totDifficultyOfBoard += ret.enemyUnits[i].myType.difficultyFactor;
}
return(totDifficultyOfBoard);
}
void chooseInfUnitFor(MarketSlot sl, GenLevel levelFrom)
{
int choice = Random.Range(0, chancesTotal);
int total = 0;
bool chosenYet = false;
for (int i = 0; i < levelFrom.availableInMarket.Length; i++)
{
total += levelFrom.marketUnitChances[i];
if (choice < total)
{
sl.assignUnit(new bUnit(levelFrom.availableInMarket[i]));
chosenYet = true;
break;
}
}
if (!chosenYet)
{
Debug.LogError("ERROR: Did not choose unit for slot");
}
}
// Update is called once per frame
void Update()
{
if (firstTimeSetup)
{
if (st.isInfinite)
{
curLevel = lg.generateLevel(curDifficulty);
loadGenLevel(curLevel, false);
}
else
{
loadLevel(levels[levelCount], false);
}
firstTimeSetup = false;
}
if (Input.GetKeyDown(KeyCode.Q) || Input.GetKeyDown(KeyCode.Escape))
{
Destroy(st.gameObject);
SceneManager.LoadScene(0);
}
switch (curPhase)
{
case GamePhase.Prep:
if (Input.GetKeyDown(marketKey))
{
unitSelectPanel.SetActive(false);
curPhase = GamePhase.Market;
mk.refreshInventory();
}
if (Mathf.CeilToInt(Camera.main.transform.eulerAngles.y) != 0)
{
Camera.main.transform.eulerAngles += new Vector3(0, cameraRotSpeed, 0);
}
break;
case GamePhase.Battle:
if (selected != null)
{
selected.GetComponent <MeshRenderer>().material = baseSlotMaterial;
selected = null;
}
timer += Time.deltaTime;
if (timer > attackDelay)
{
//Debug.Log("battle tick");
timer -= attackDelay;
if (curAttackersHighlighted)
{
executeAttack();
}
else
{
if (fightToDeath)
{
if (friendlyUnitCount > 0 && enemyUnitCount > 0)
{
//fight isn't over, initiate a new attack.
chooseAttackers();
}
else
{
triggerFightEnds();
//fight is over, determine who won/tie.
if (friendlyUnitCount > 0)
{
//win condition.
//basic next-level stuff
levelCount++;
//mk.emptyStoredMarket();
if (!st.isInfinite)
{
//pre-set levels condition.
if (levelCount == levels.Length)
{
endScreen("You Win!");
}
else
{
curPhase = GamePhase.Transition;
clearLevel();
loadLevel(levels[levelCount], false);
}
}
else
{
//infinite level generation condition.
curDifficulty += diffIncr;
curPhase = GamePhase.Transition;
clearLevel();
curLevel = lg.generateLevel(curDifficulty);
loadGenLevel(curLevel, false);
}
}
else if (enemyUnitCount > 0)
{
//loseCondition
string printer = "Unfortunately, you died.";
if (st.isInfinite)
{
printer += "\n You beat: " + levelCount + " levels.";
}
endScreen(printer);
}
else
{
//tie condition
curPhase = GamePhase.Transition;
clearLevel();
ih.clearInv();
ih.unitInventory.AddRange(ih.invBackup);
if (!st.isInfinite)
{
loadLevel(levels[levelCount], true);
}
else
{
resetUnitsInLevel(curLevel);
loadGenLevel(curLevel, true);
}
}
curPhase = GamePhase.Prep;
timer = 0;
GameObject.Find("TurnPhaseText").GetComponent <Text>().text = "Prep Phase";
}
}
else
{
//Totally unimplemented fights that consist of a single pass through.
Debug.Log("One iteration attack");
}
}
}
break;
case GamePhase.Market:
if (Mathf.CeilToInt(Camera.main.transform.eulerAngles.y) != 180)
{
Camera.main.transform.eulerAngles += new Vector3(0, cameraRotSpeed, 0);
}
if (Input.GetKeyDown(marketKey))
{
mk.endMarketPhase();
}
break;
default:
break;
}
}
public GenLevel generateLevel(float difficulty)
{
//This function works off the premise that we're trying to get the difficulty
//float as close to zero as possible. Adding difficult things will SUBTRACT from said
//float, while making things easier will ADD to the float.
//I will make this better in the future I promise.
GenLevel ret = new GenLevel();
//Choose number of friendlies and enemies
int numEnemies = Random.Range(2, 7);
difficulty -= numEnemies * enemyCountWeight;
int numFriendlies;
if (numEnemies > 4)
{
numFriendlies = Random.Range(4, 7);
}
else
{
numFriendlies = Random.Range(2, 7);
}
difficulty += numFriendlies * friendlyCountWeight;
ret.enemySlotNum = numEnemies;
ret.friendlySlotNum = numFriendlies;
//Setup chances of different enemies
//for now, its a simple and dumb system.
if (genRandChances)
{
unitOptionChances = new int[unitOptionsCount];
for (int i = 0; i < unitOptionsCount; i++)
{
if (unitList[i].difficultyFactor * numEnemies > difficulty)
{
unitOptionChances[i] = Random.Range(1, 4);
}
else
{
unitOptionChances[i] = Random.Range(3, 8);
}
}
}
//Setup enemy board
//NOTE: At this point, chances of various units should be set based on difficulty remaining
difficulty -= chooseEnemiesForCount(ret, numEnemies);
//choose available units in market
//First, choose how many options there are.
int numAvailableInMarket = Random.Range(2, unitOptionsCount);
//int numAvailableInMarket = 2;
ret.availableInMarket = new BaseUnit[numAvailableInMarket];
//Then, choose what the options actually are.
List <BaseUnit> optionsRemaining = new List <BaseUnit>();
optionsRemaining.AddRange(unitList);
for (int i = 0; i < numAvailableInMarket; i++)
{
BaseUnit choice = optionsRemaining[Random.Range(0, optionsRemaining.Count)];
ret.availableInMarket[i] = choice;
optionsRemaining.Remove(choice);
difficulty += choice.difficultyFactor;
}
//Finally, choose the shop chance for each unit
//Could be done in the above loop, but I like splitting them up for clarity.
ret.marketUnitChances = new int[numAvailableInMarket];
for (int i = 0; i < numAvailableInMarket; i++)
{
//TODO: CHANGE.
ret.marketUnitChances[i] = (int)(10 / ret.availableInMarket[i].difficultyFactor);
}
//choose number of shop slots
int numSlotsAvailable = Random.Range(3, 14);
difficulty += numSlotsAvailable * marketCountWeight;
ret.numShopSlots = numSlotsAvailable;
//If the enemy has a Jenn, the market MUST contain at least one unit capable of damaging her, e.g. it cannot be a market full of Dans.
if (hasType("Jenn", ret.enemyUnits))
{
marketMustContain(ret.availableInMarket, JennCounters);
}
//If the enemy has a Sai, the market MUST contain either a Sai, Val, or Mark.
if (hasType("Sai", ret.enemyUnits))
{
marketMustContain(ret.availableInMarket, SaiCounters);
}
//Finally, choose the starting ctrl at a value that attempts to offset remaining difficulty.
if (difficulty < ctrlBoostOffset)
{
ret.startingCtrl = Random.Range(10, 30);
}
else
{
ret.startingCtrl = Random.Range(3, 10);
}
difficulty += ret.startingCtrl * ctrlWeight;
//NEW METHOD FOR CTRL
//Add exactly enough to offset.
/*if(difficulty < ctrlBoostOffset)
* {
* ret.startingCtrl = Mathf.CeilToInt((ctrlBoostOffset - difficulty)/ctrlWeight);
* }*/
/*Debug.Log("Post-generation, remaining difficulty was as follows.");
* Debug.Log(difficulty);
* Debug.Log("(hopefully should be close to zero)");*/
/*Debug.Log("Units available:");
* foreach(BaseUnit unit in ret.availableInMarket)
* {
* Debug.Log(unit.unitName);
* }
* Debug.Log("Odds:");
* foreach(int x in ret.marketUnitChances)
* {
* Debug.Log("" + x);
* }*/
return(ret);
}
public void initLevel(GenLevel level)
{
}
public GenFloor generateObj()
{
int x = 0;
int y = 0;
// Random.seed = System.Guid.NewGuid ().GetHashCode ();
// TODO: (defensive) first check any required variables un-init
GenFloor floor = new GenFloor();
variablesList = new List <GenVariable> ();
variablesCounter = 1;
eventsList = new List <GenEvents>();
eresultList = new List <GenEResults>();
// int levelNum = randomGen (levelCount);
int levelNum = 1;
floor.levels = new GenLevel[levelNum];
for (int levelNo = 1; levelNo <= levelNum; levelNo++)
{
branchableGates = new List <GenGate> ();
occupiedArea = new List <Rect> ();
GenLevel level = new GenLevel();
// currentWorkingLevel = level;
//level.events = new List<GenEvent> ();
level.levelId = levelNo;
int mainline = mainlineLength;
// mainline generating
level.startingRoom = genNextRoom(x, y, true, (levelNo == levelNum), mainline);
// branch generating
for (int i = 0; i < roomNum - mainline; i++)
{
GenRoom newRoom;
GenBridge newBridge;
GenGate selectedGate;
do
{
if (branchableGates.Count == 0)
{
selectedGate = null;
newRoom = null;
newBridge = null;
break;
}
int randomIndex = Random.Range(0, branchableGates.Count - 1);
selectedGate = branchableGates[randomIndex];
newBridge = genBridge(selectedGate.x, selectedGate.y, selectedGate.direction);
newRoom = genNextRoom(newBridge.x, newBridge.y, false, false, 0, (selectedGate.direction < 2 ? selectedGate.direction + 2 : selectedGate.direction - 2));
if (newRoom == null)
{
branchableGates.RemoveAt(randomIndex);
}
} while(newRoom == null);
if (selectedGate != null && newRoom != null && newBridge != null)
{
branchableGates.Remove(selectedGate);
selectedGate.isGateOpen = true;
selectedGate.bridge = newBridge;
selectedGate.bridge.targetRoom = newRoom;
genGateEvent(newRoom, selectedGate.direction);
}
}
//mark by gpf
// if(levelNo == levelNum)
// {
// // Boss room generate
// level.bossRoom = genNextRoom(1000, 1000, false);
// level.bossRoom.monsters = new GenMonster[1];
// // get a position for boss
// // TODO: stop using silly method
// Room roomData = new Room (level.bossRoom.roomObjId);
// bool validPos = false;
// Pos position = new Pos(0, 0);
// while(!validPos) {
// position.x = Random.Range (0, 13);
// position.y = Random.Range (0, 13);
// if(roomData.landscape[position.y][position.x] == 1) {
// validPos = true;
// }
// }
// roomData.landscape[position.y][position.x] = 0;
// level.bossRoom.monsters[0] = genMonster(0, position);
// level.bossRoom.monsters[0].appearCondId = 0;
// level.bossRoom.monsters [0].monsterObjId = 2;
// // make the event that when the boss is killed, player wins
// // level.bossRoom.monsters[0].events = new List<GenEvent>();
// // GenEvent newGE = new GenEvent();
// // newGE.triggerTypeId = GenEvent.TriggerType.MONSTER_DIE;
// // newGE.results = new GenEventResult[1];
// // GenEventResult newGER = new GenEventResult();
// // newGER.resultTypeId = GenEvent.ResultType.FLOOR_CLEAR;
// // newGE.results[0] = newGER;
// // level.bossRoom.monsters[0].events.Add(newGE);
//
//gen event added by kone
//GenEvents genEvent = new GenEvents();
//genEvent.eventId = 1;
//genEvent.triggerTypeId = GenEvents.TriggerType.MONSTER_DIE;
//genEvent.levelId = level.levelId;
//genEvent.roomId = level.bossRoom.roomId;
//genEvent.triggerParams = new int[1];
//genEvent.triggerParams[0] = level.bossRoom.monsters[0].monsterId;
//eventsList.Add(genEvent);
//GenEResults genEResult = new GenEResults();
//genEResult.resultTypeId = GenEResults.ResultType.FLOOR_CLEAR;
//genEResult.eventId = 1;
//eresultList.Add(genEResult);
// // get char Position
// validPos = false;
// position = new Pos(0, 0);
// while(!validPos) {
// position.x = Random.Range (0, 13);
// position.y = Random.Range (0, 13);
// if(roomData.landscape[position.y][position.x] == 1) {
// validPos = true;
// }
// }
// level.bossRoom.charPosition = position;
// roomData.landscape[position.y][position.x] = 0;
// }
floor.levels [levelNo - 1] = level;
}
floor.monsters = new GenMonsterObj[3];
// normal monster
floor.monsters [0] = new GenMonsterObj();
floor.monsters [0].monsterObjId = 0;
floor.monsters[0].monsterSettingId = monstersettingID;
// stronger monster
floor.monsters [1] = new GenMonsterObj();
floor.monsters [1].monsterObjId = 1;
floor.monsters[1].monsterSettingId = monstersettingID;
floor.monsters [1].skills = new GenSkill[2];
floor.monsters [1].skills [0] = new GenSkill();
floor.monsters [1].skills [0].skillId = 1;
floor.monsters [1].skills [1] = new GenSkill();
floor.monsters [1].skills [1].skillId = 2;
floor.monsters [1].skills [1].skillParam = new int[2];
floor.monsters [1].skills [1].skillParam[0] = 150;
floor.monsters [1].skills [1].skillParam[1] = 5;
// boss
floor.monsters [2] = new GenMonsterObj();
floor.monsters [2].monsterObjId = 2;
floor.monsters[2].monsterSettingId = monstersettingID;
floor.monsters [2].skills = new GenSkill[2];
floor.monsters [2].skills [0] = new GenSkill();
floor.monsters [2].skills [0].skillId = 1;
floor.monsters [2].skills [1] = new GenSkill();
floor.monsters [2].skills [1].skillId = 2;
floor.monsters [2].skills [1].skillParam = new int[1];
floor.monsters [2].skills [1].skillParam[0] = 220;
//floor.variables = variablesList.ToArray ();
floor.events = eventsList.ToArray();
floor.eresults = eresultList.ToArray();
return(floor);
}
