// Update is called once per frame
void Update()
{
if (CrossPlatformInputManager.GetAxisRaw("Tool") > 0)
{
var trees = GameObject.FindGameObjectsWithTag("Tree");
foreach (GameObject tree in trees)
{
if (Vector3.Distance(transform.position, tree.transform.position) < 3)
{
audioSource.Play();
Destroy(tree);
LevelProgression.AddWood(10);
LevelProgression.AddSeeds(5);
}
}
var rocks = GameObject.FindGameObjectsWithTag("Rock");
foreach (GameObject rock in rocks)
{
if (Vector3.Distance(transform.position, rock.transform.position) < 30)
{
audioSource.Play();
Destroy(rock);
LevelProgression.AddStone(10);
}
}
}
}
void SpawnObject()
{
Building building = buildings[index];
if (LevelProgression.getLevel() >= building.lvlReq &&
LevelProgression.getWood() >= building.woodCost &&
LevelProgression.getStone() >= building.stoneCost &&
LevelProgression.getSeeds() >= building.seedCost) // Check if buildable
{
// Update game values
LevelProgression.AddCivPoints(building.civVal);
LevelProgression.AddPollPoints(building.polVal);
LevelProgression.AddSeeds(-1 * building.seedCost);
LevelProgression.AddWood(-1 * building.woodCost);
LevelProgression.AddStone(-1 * building.stoneCost);
// Calc location to spawn
GameObject prefab = building.obj;
Vector3 playerPos = player.transform.position;
Vector3 playerDirection = player.transform.forward;
Vector3 spawnPos = playerPos + playerDirection * spawnDistance;
spawnPos.Set(spawnPos.x, spawnPos.y, spawnPos.z);
// Spawn new object
Instantiate(prefab, spawnPos, prefab.transform.rotation);
}
}
public bool DeepEquals(DestinyCharacterComponent?other)
{
return(other is not null &&
MembershipId == other.MembershipId &&
MembershipType == other.MembershipType &&
CharacterId == other.CharacterId &&
DateLastPlayed == other.DateLastPlayed &&
MinutesPlayedThisSession == other.MinutesPlayedThisSession &&
MinutesPlayedTotal == other.MinutesPlayedTotal &&
Light == other.Light &&
Stats.DeepEqualsDictionaryNaive(other.Stats) &&
RaceHash == other.RaceHash &&
GenderHash == other.GenderHash &&
ClassHash == other.ClassHash &&
RaceType == other.RaceType &&
ClassType == other.ClassType &&
GenderType == other.GenderType &&
EmblemPath == other.EmblemPath &&
EmblemBackgroundPath == other.EmblemBackgroundPath &&
EmblemHash == other.EmblemHash &&
(EmblemColor is not null ? EmblemColor.DeepEquals(other.EmblemColor) : other.EmblemColor is null) &&
(LevelProgression is not null ? LevelProgression.DeepEquals(other.LevelProgression) : other.LevelProgression is null) &&
BaseCharacterLevel == other.BaseCharacterLevel &&
PercentToNextLevel == other.PercentToNextLevel &&
TitleRecordHash == other.TitleRecordHash);
}
public void DrawLevel(LevelProgression levelProgression)
{
CalculateVisualCenter(levelProgression);
DrawBackground(levelProgression);
DrawGrounds();
DrawObstacles(levelProgression);
DrawCollectibles(levelProgression);
DrawProjectiles(levelProgression);
DrawPlayer(levelProgression);
if (levelProgression.IsLevelComplete)
{
DrawLevelCompleteScreen(0.92f);
}
if (level.IsTutorial)
{
DrawTutorialInfoTexture(levelProgression);
}
if (levelProgression.IsGamePaused)
{
DrawPauseScreen();
}
}
private void DrawObstacles(LevelProgression levelProgression)
{
foreach (Obstacle obstacle in level.Obstacles)
{
DrawObstacle(obstacle);
}
}
private void DrawCollectibles(LevelProgression levelProgression)
{
foreach (KeyValuePair <int, int> csv in collectiblesStateValues.ToList())
{
collectiblesStateValues[csv.Key] = csv.Value - 1;
}
foreach (Collectible collectible in level.Collectibles)
{
int id = collectible.ID;
int stateValue = collectibleMaximumValue;
if (levelProgression.IsCollectibleAlreadyCollected(collectible))
{
if (!collectiblesStateValues.ContainsKey(id))
{
collectiblesStateValues.Add(id, 60);
}
stateValue = collectiblesStateValues[id];
}
float halfCollectibleWidth = VisualValues.HalfCollectibleWidthHeight * 0.95f;
float leftX = collectible.Position.X - halfCollectibleWidth;
float rightX = collectible.Position.X + halfCollectibleWidth;
DrawCollectible(collectible, stateValue);
}
}
public void Update()
{
SelectedCompanion = LevelProgression.GetComponent <CompanionProgression>().SelectedCompanion;
if (RunMe == true)
{
CompanionSwitch();
}
}
private void Start()
{
debugPanel.SetActive(visable);
playerHealth = FindObjectOfType <PlayerHealth>();
enemies = FindObjectsOfType <EnemyHealth>();
levelProgression = FindObjectOfType <LevelProgression>();
}
public static void ClearSaveData()
{
PlayerPrefs.DeleteAll();
PlayerPrefs.Save();
LevelProgression.Init();
Save();
Load();
}
public static void Save()
{
SaveData saveData = new SaveData {
levelProgressionSave = LevelProgression.Save()
};
PlayerPrefs.SetString("SaveData", JsonUtility.ToJson(saveData));
PlayerPrefs.Save();
}
// Update is called once per frame
void Update()
{
civPoints.text = LevelProgression.getCivPoints().ToString();
level.text = LevelProgression.getLevel().ToString();
polPoints.text = LevelProgression.getPollPoints().ToString();
stoneCount.text = LevelProgression.getStone().ToString();
woodCount.text = LevelProgression.getWood().ToString();
seedCount.text = LevelProgression.getSeeds().ToString();
}
private void CheckPlayerObstacleCollision()
{
LevelProgression levelProgression = GetLevelProgression();
if (collisions.DoesPlayerCollideWithAnObstacle(levelProgression))
{
AddPlayerFail();
}
}
public static void Load()
{
string loadSaveData = PlayerPrefs.GetString("SaveData", "");
if (loadSaveData != "")
{
SaveData saveData = JsonUtility.FromJson <SaveData>(loadSaveData);
LevelProgression.Load(saveData.levelProgressionSave);
}
}
private void OnCollisionEnter(Collision other)
{
GameObject player = FindObjectOfType <PlayerHealth>().gameObject;
LevelProgression LP = FindObjectOfType <LevelProgression>();
if (other.gameObject == player)
{
LP.LevelUnlocked[unlockLevel] = true;
Destroy(this.gameObject);
}
}
private void Awake()
{
if (isInit)
{
return; // Only Initialize once
}
isInit = true;
LevelProgression.Init();
SaveSystem.Init();
}
//bools used for level completion.
private void Awake()
{
if (Instance == null)
{
Instance = this;
DontDestroyOnLoad(this.gameObject);
}
else
{
Destroy(this.gameObject);
}
}
private void Awake() {
Transform levelContainer = transform.Find("LevelContainer");
foreach (Transform levelTransform in levelContainer) {
LevelNumberSO levelNumberSO = levelTransform.GetComponent<LevelNumberSOHolder>().levelNumberSO;
if (unlockAllLevels || LevelProgression.IsLevelUnlocked(levelNumberSO)) {
// Level Unlocked
levelTransform.GetComponent<Button>().enabled = true;
levelTransform.Find("Star_1").gameObject.SetActive(true);
levelTransform.Find("Star_2").gameObject.SetActive(true);
levelTransform.Find("Star_3").gameObject.SetActive(true);
levelTransform.Find("Star_1").GetComponent<Image>().color = starUnachievedColor;
levelTransform.Find("Star_2").GetComponent<Image>().color = starUnachievedColor;
levelTransform.Find("Star_3").GetComponent<Image>().color = starUnachievedColor;
LevelProgression.LevelStars levelStars = LevelProgression.GetLevelStars(levelNumberSO);
switch (levelStars) {
case LevelProgression.LevelStars._0:
levelTransform.Find("Star_1").gameObject.SetActive(false);
levelTransform.Find("Star_2").gameObject.SetActive(false);
levelTransform.Find("Star_3").gameObject.SetActive(false);
break;
case LevelProgression.LevelStars._1:
levelTransform.Find("Star_1").GetComponent<Image>().color = starAchievedColor;
break;
case LevelProgression.LevelStars._2:
levelTransform.Find("Star_1").GetComponent<Image>().color = starAchievedColor;
levelTransform.Find("Star_2").GetComponent<Image>().color = starAchievedColor;
break;
case LevelProgression.LevelStars._3:
levelTransform.Find("Star_1").GetComponent<Image>().color = starAchievedColor;
levelTransform.Find("Star_2").GetComponent<Image>().color = starAchievedColor;
levelTransform.Find("Star_3").GetComponent<Image>().color = starAchievedColor;
break;
}
} else {
// Level Locked
levelTransform.GetComponent<Button>().enabled = false;
levelTransform.GetComponent<Image>().color = levelLockedColor;
levelTransform.Find("Star_1").gameObject.SetActive(false);
levelTransform.Find("Star_2").gameObject.SetActive(false);
levelTransform.Find("Star_3").gameObject.SetActive(false);
}
}
transform.Find("LockUnlockAllBtn").Find("Text").GetComponent<TextMeshProUGUI>().text = (unlockAllLevels ? "LOCK" : "UNLOCK") + " ALL LEVELS";
}
private void CheckPlayerCollectibleCollision()
{
LevelProgression levelProgression = GetLevelProgression();
List <Collectible> collectedCollectibles = collisions.GetPlayerCollectibleCollisions(levelProgression);
foreach (Collectible collectible in collectedCollectibles)
{
levelProgression.CollectCollectible(collectible);
levelProgression.AddPoints(GameplayValues.PointsForCollectible);
}
}
private void DrawProjectiles(LevelProgression levelProgression)
{
foreach (Projectile projectile in level.Projectiles)
{
float halfProjectileWidth = VisualValues.HalfProjectileWidthHeight * 0.95f;
Vector2 projectilePosition = levelProgression.GetProjectilePosition(projectile);
float leftX = projectilePosition.X - halfProjectileWidth;
float rightX = projectilePosition.X + halfProjectileWidth;
DrawProjectile(projectilePosition);
}
}
public void Start()
{
Player = GameObject.Find("/Player Character/PlayerCharacter_BaseRig");
CompanionRespawnPoint = GameObject.Find("/Player Character/PlayerCharacter_BaseRig/CompanionRespawn");
LevelProgression = GameObject.Find("/LevelProgression");
HealthCompanion = GameObject.Find("/Companion_Pig");
DamageCompanion = GameObject.Find("/Companion_Bee");
SpeedCompanion = GameObject.Find("/Companion_Crow");
DefenseCompanion = GameObject.Find("/Companion_Turtle");
BasePlayerHealth = Player.GetComponent <PlayerHealth>().healthMax;
BasePlayerDamage = Player.GetComponent <PlayerAttack>().attackDamage;
BasePlayerSpeed = Player.GetComponent <PlayerMovement>().tempSpeed;
SelectedCompanion = LevelProgression.GetComponent <CompanionProgression>().SelectedCompanion;
CompanionSwitch();
}
public bool DoesPlayerCollideWithAnObstacle(LevelProgression levelProgression)
{
Hitbox playerHitbox = GetPlayerHitbox(levelProgression.CurrentPlayerPosition, levelProgression.IsPlayerStanding);
foreach (Obstacle obstacle in level.Obstacles)
{
Hitbox obstacleHitbox = Hitboxes.GetObstacleHitbox(obstacle);
if (playerHitbox.CollidesWith(obstacleHitbox))
{
return(true);
}
}
return(false);
}
private void CheckPlayerProjectileCollision()
{
LevelProgression levelProgression = GetLevelProgression();
List <Projectile> projectilesCollidedWith = collisions.GetPlayerProjectileCollisions(levelProgression);
foreach (Projectile projectile in projectilesCollidedWith)
{
if (levelProgression.IsPlayerDefending)
{
DeflectProjectile(projectile);
}
else
{
AddPlayerFail();
}
}
}
private void DrawPlayer(LevelProgression levelProgression)
{
Texture playerTexture;
if (levelProgression.IsPlayerInGodmode())
{
playerTexture = playerGhostTexture;
}
else if (levelProgression.IsPlayerDefending)
{
playerTexture = playerDefendingTexture;
}
else
{
playerTexture = playerStandardTexture;
}
Vector2 playerPosition = levelProgression.CurrentPlayerPosition;
float x1 = playerPosition.X - (VisualValues.PlayerWidth / 2.0f);
float x2 = playerPosition.X + (VisualValues.PlayerWidth / 2.0f);
float y1 = playerPosition.Y + VisualValues.PlayerHeight;
if (!levelProgression.IsPlayerStanding)
{
x1 = playerPosition.X - (VisualValues.PlayerHeight / 2.0f);
x2 = playerPosition.X + (VisualValues.PlayerHeight / 2.0f);
y1 = playerPosition.Y + VisualValues.PlayerWidth;
}
Vector2 v1 = new Vector2(x1, y1);
Vector2 v2 = new Vector2(x2, playerPosition.Y);
if (levelProgression.IsPlayerStanding)
{
DrawAdjustedTexture(playerTexture, v1, v2);
}
else
{
DrawAdjustedTextureVertically(playerTexture, v1, v2);
}
}
private void SetNewProjectilePositions()
{
LevelProgression levelProgression = GetLevelProgression();
foreach (Projectile projectile in levelAttempt.Level.Projectiles)
{
Vector2 movementDelta;
if (levelProgression.IsProjectileDeflected(projectile))
{
movementDelta = levelProgression.GetProjectileDeflectionDirection(projectile) / GeneralValues.FPS;
}
else
{
movementDelta = new Vector2(-PhysicsValues.GetProjectileVelocityPerFrame(), 0);
}
levelProgression.MoveProjectile(projectile, movementDelta);
}
}
private void DrawTutorialInfoTexture(LevelProgression levelProgression)
{
Texture tutorialTexture;
if (level.Name == "TutorialLevel1")
{
tutorialTexture = tutorialJumpTexture;
}
else if (level.Name == "TutorialLevel2")
{
tutorialTexture = tutorialDuckTexture;
}
else
{
tutorialTexture = tutorialDeflectTexture;
}
bool showSecondInfo = levelProgression.CurrentPlayerPosition.X > 10;
Vector2 topLeftCorner = new Vector2(-0.6f, 0.8f);
Vector2 bottomRightCorner = new Vector2(0.6f, 0.4f);
if (showSecondInfo)
{
topLeftCorner = new Vector2(-1.3f, 0.8f);
bottomRightCorner = new Vector2(-0.1f, 0.4f);
}
DrawTexture(tutorialTexture, topLeftCorner, bottomRightCorner);
if (showSecondInfo)
{
Vector2 topLeftCorner2 = new Vector2(0.1f, 0.8f);
Vector2 bottomRightCorner2 = new Vector2(1.3f, 0.4f);
Texture secondInfoTexture = level.Name == "TutorialLevel3" ?
tutorialComplete : tutorialNextTutorial;
DrawTexture(secondInfoTexture, topLeftCorner2, bottomRightCorner2);
}
}
public bool GeneratePreviewJob(CareerStatus status, CareerStatus.State state)
{
bool flag = status.GetStarRating() >= 5f || UnityEngine.Random.Range(0, 100) > 50;
int num = LevelProgression.GetZeroIndexedLevel(state.m_kudos) + 1;
int minKudos = (!flag) ? state.m_kudos : LevelProgression.GetThreshold(num);
int maxKudos = (!flag) ? state.m_kudos : LevelProgression.GetThreshold(num + 1);
float minStarRating = (!flag) ? (status.GetStarRating() + 0.1f) : 0f;
float maxStarRating = (!flag) ? (status.GetStarRating() + 1f) : 0f;
bool includeStory = false;
bool expandRatingSearch = false;
Job job = status.m_career.GenerateJob(minKudos, maxKudos, minStarRating, maxStarRating, includeStory, state.m_completedJobs, status.GetCurrentJobDesc(), state.m_generatedJobs, expandRatingSearch);
if (job != null)
{
ModLogs.Log("Budget from " + job.GetDesc().m_from + " value $" + job.m_budget);
job.m_budget = job.m_budget + ((job.m_budget * percentage) / 100);
status.AddJob(job);
return(true);
}
return(false);
}
private Vector2 GetVisualCenter(LevelProgression levelProgression)
{
Vector2 playerPosition = levelProgression.CurrentPlayerPosition;
Ground groundBelowPlayer = LevelAnalysis.GetGroundBelowVector(level, playerPosition);
if (hasPlayerLeftCurrentGround)
{
if (groundBelowPlayer != null)
{
if (Math.Abs(playerPosition.Y - groundBelowPlayer.TopY) < 0.001f)
{
hasPlayerLeftCurrentGround = false;
}
}
return(new Vector2(playerPosition.X, Math.Min(lastGroundTopY, playerPosition.Y)));
}
if (groundBelowPlayer != null)
{
return(new Vector2(playerPosition.X, groundBelowPlayer.TopY));
}
if (!hasPlayerLeftCurrentGround)
{
hasPlayerLeftCurrentGround = true;
}
Ground groundLeftFromPlayer = LevelAnalysis.GetGroundLeftFromVector(level, playerPosition);
lastGroundTopY = groundLeftFromPlayer.TopY;
if (groundLeftFromPlayer == null)
{
return(playerPosition);
}
return(new Vector2(playerPosition.X, Math.Min(groundLeftFromPlayer.TopY, playerPosition.Y)));
}
/*
* public bool DoesPlayerCollideWithASolidObstacle(LevelProgression levelProgression)
* {
* return DoesPlayerCollideWithASolidObstacle(levelProgression.CurrentPlayerPosition,
* levelProgression.IsPlayerStanding);
* }
*
* private bool DoesPlayerCollideWithASolidObstacle(Vector2 playerPosition, bool isPlayerStanding)
* {
* Hitbox playerHitbox = GetPlayerHitbox(playerPosition, isPlayerStanding);
*
* foreach (Obstacle obstacle in level.SolidObstacles)
* {
* Hitbox obstacleHitbox = Hitboxes.GetObstacleHitbox(obstacle);
*
* if (playerHitbox.CollidesWith(obstacleHitbox)) return true;
* }
*
* return false;
* }
*/
public List <Collectible> GetPlayerCollectibleCollisions(LevelProgression levelProgression)
{
List <Collectible> collectedCollectibles = new List <Collectible>();
Hitbox playerHitbox = GetPlayerHitbox(levelProgression.CurrentPlayerPosition, levelProgression.IsPlayerStanding);
foreach (Collectible collectible in level.Collectibles)
{
if (levelProgression.IsCollectibleAlreadyCollected(collectible))
{
continue;
}
Hitbox collectibleHitbox = Hitboxes.GetCollectibleHitbox(collectible);
if (playerHitbox.CollidesWith(collectibleHitbox))
{
collectedCollectibles.Add(collectible);
}
}
return(collectedCollectibles);
}
public List <Projectile> GetPlayerProjectileCollisions(LevelProgression levelProgression)
{
List <Projectile> projectilesCollidedWith = new List <Projectile>();
Hitbox playerHitbox = GetPlayerHitbox(levelProgression.CurrentPlayerPosition, levelProgression.IsPlayerStanding);
foreach (Projectile projectile in level.Projectiles)
{
if (levelProgression.IsProjectileDeflected(projectile))
{
continue;
}
Hitbox projectileHitbox = Hitboxes.GetProjectileHitbox(levelProgression.GetProjectilePosition(projectile));
if (playerHitbox.CollidesWith(projectileHitbox))
{
projectilesCollidedWith.Add(projectile);
}
}
return(projectilesCollidedWith);
}
private void Start()
{
playerstats = GameObject.FindGameObjectWithTag("Player").GetComponent <CharacterStats>();
levelProgression = GameObject.FindGameObjectWithTag("StartManager").GetComponent <LevelProgression>();
soundmanager = GameObject.FindGameObjectWithTag("SoundFXManager").GetComponent <SoundManager>();
}
