// Use this for initialization
void Start()
{
player = GameObject.FindObjectOfType<Player>();
canvas = GetComponent<Canvas>();
canvas.enabled = false;
state = GameObject.FindObjectOfType<LevelState>();
}
public MetaLevel(String title, String id, String thumbnail)
{
this.title = title;
this.thumbnailResource = thumbnail;
this.state = LevelState.LOCKED;
this.id = id;
}
public static void addState(LevelState aState)
{
if (levelStates == null)
levelStates = new List<LevelState>();
levelStates.Add(aState);
}
// Use this for initialization
void Start()
{
Cardboard.SDK.OnTrigger += PullTrigger;
head = GameObject.FindObjectOfType<CardboardHead>();
rb = GetComponent<Rigidbody>();
state = GameObject.FindObjectOfType<LevelState>();
}
public void Update(LevelState state)
{
if (!init)
{
foreach (var faction in state.Factions)
{
//Points.Add(faction.SlotIndex, faction.Points);
//if (OnNewEvent != null)
// OnNewEvent(new FactionPointsEntry() {
// Round = state.Round,
// SlotIndex = faction.SlotIndex,
// Points = faction.Points
// });
}
init = true;
}
foreach (var faction in state.Factions)
{
//if (Points[faction.SlotIndex] != faction.Points)
//{
// Points[faction.SlotIndex] = faction.Points;
// if (OnNewEvent != null)
// OnNewEvent(new FactionPointsEntry()
// {
// Round = state.Round,
// SlotIndex = faction.SlotIndex,
// Points = faction.Points
// });
//}
}
}
public Level()
{
Waves = new List<Wave>();
_currentState = LevelState.BEGIN;
_currentTime = TimeSpan.Zero;
_currentWave = 0;
////Debug.WriteLine("LEVEL: Begin Wave");
}
public Level(int index, string name, int checkpoints, LevelState state,Vector3 position)
{
this.mLevelIndex = index;
this.mLevelName = name;
this.mCheckPoint = checkpoints;
this.mState = state;
this.mPlayerPosition = position;
}
public Level(int index, string name,int checkpoints)
{
this.mLevelIndex = index;
this.mLevelName = name;
this.mCheckPoint = checkpoints;
this.mState = LevelState.UNLOADED;
this.mPlayerPosition = Vector3.zero;
}
public Level()
{
this.mLevelIndex = 0;
this.mLevelName = "";
this.mCheckPoint = 0;
this.mState = LevelState.UNLOADED;
this.mPlayerPosition = Vector3.zero;
}
protected override void LoadData(MemoryStream ms)
{
IFormatter formatter = new BinaryFormatter();
GameState gd = (GameState)formatter.Deserialize(ms);
this.CultistState = gd.CultistState == null ? new CultistState() : gd.CultistState;
this.LevelState = gd.LevelState == null ? new LevelState() : gd.LevelState;
}
public Level()
{
Waves = new List<Wave>();
_currentState = LevelState.BEGINWAVING;
_currentTime = TimeSpan.Zero;
_currentWave = 0;
IsFirstZombie = true;
////Debug.WriteLine("LEVEL: Begin Wave");
}
public void LoadLevel(int levelIndex)
{
if( thisLevelState != LevelState.OpeningCredits )
SoundtrackManager.s_instance.PlayAudioSource (SoundtrackManager.s_instance.beep);
loadingBarScreen.alpha = 1;
StartCoroutine (LevelLoader (levelIndex));
lastLevelState = thisLevelState;
thisLevelState = (LevelState)levelIndex;
}
public Level(MainWindow window)
{
this.window = window;
levelOne = new LevelOne(this);
levelTwo = new LevelTwo(this);
levelThree = new LevelThree(this);
bossLevel = new BossLevel(this);
setLevelState(levelOne);
dispatcher = Dispatcher.CurrentDispatcher;
}
public void SetCurrentLevelState(LevelState state)
{
int curLevel = Main.instance.sceneManager.curLevel;
SetLevelState(curLevel, state);
//unlock next level
if(state == LevelState.Complete && GetLevelState(curLevel+1) == LevelState.Locked) {
SetLevelState(curLevel+1, LevelState.Unlocked);
}
}
public Level(Game game, SpriteBatch spriteBatch, int levelNumber,
int movesPerformed, Texture2D buttonsTexture)
: base(game)
{
this.levelNumber = levelNumber;
this.spriteBatch = spriteBatch;
CurrentState = LevelState.NotReady;
this.buttonsTexture = buttonsTexture;
MovesPerformed = movesPerformed;
}
public virtual void StartLevel()
{
var enemiesLayer = LayerMask.NameToLayer( "Enemies" );
var playerLayer = LayerMask.NameToLayer( "Player" );
Physics.IgnoreLayerCollision( enemiesLayer, enemiesLayer );
Physics.IgnoreLayerCollision( playerLayer, playerLayer );
State = LevelState.Running;
LevelRunningCoroutine = Locator.Coroutines.RunCoroutine( LevelRunning() );
}
public virtual void Pause()
{
if ( State == LevelState.Done )
return;
State = State == LevelState.Running ? LevelState.Paused : LevelState.Running;
TimeProvider.Pause = State == LevelState.Paused;
if ( State == LevelState.Paused )
pauseMenu = Locator.UI.Show< PauseMenu >();
else
pauseMenu.Close();
}
public void Load()
{
levelState = LevelState.LOADING_SAVE;
// load container data
serializer.Load(container.saveSlot);
// allow 3 frames to be skipped after save to fix ragdoll bug
skipUpdateFrames = 3;
Time.timeScale = 1;
//GameManager.instance.gameState = GameState.RUNNING;
}
public Game1()
{
DEATH_COUNTER = 0;
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
curLevel = LevelState.Start;
level1 = new Level1(this);
level2 = new Level2(this);
level3 = new Level3(this);
level4 = new Level.Level4(this);
level5 = new Level.Level5(this);
level6 = new Level.Level6(this);
}
public static void SetState(LevelState state)
{
switch (state)
{
case LevelState.WAITING:
Timer = Utilities.Time + 5;
break;
case LevelState.PLAYING:
break;
}
CurrentState = state;
TimeSinceStart = Utilities.Time;
if (OnStateChange != null)
OnStateChange(CurrentState);
}
// Use this for initialization
void Start()
{
audSource = this.GetComponent<AudioSource>();
levelState = LevelState.Starting;
//CountdownAmount = levelStartTime / CountdownSize;
//audioSource = this.GetComponent<AudioSource>();
//audioSource.loop = false;
//CurrentAudioClip = CountdownSize;
//audioSource.clip = levelStartNumberClips[CurrentAudioClip - 1];
//audioSource.Play();
//if (showStartTimer)
// levelText.text = "" + CurrentAudioClip;
//else
// levelText.text = "";
}
public StateHandler()
{
_score = 0;
_gamestate = GameState.Menu;
_menustate = MenuState.MainMenu;
_levelstate = LevelState.Level1;
_transitionstate = TransitionState.LevelStart;
_characterstate = CharacterState.Standing;
_characterskin = Skins.Mario;
_nextgamestate = GameState.Menu;
_nextmenustate = MenuState.MainMenu;
_nextlevelstate = LevelState.Level1;
_nexttransitionstate = TransitionState.LevelStart;
_nextcharacterstate = CharacterState.Standing;
_nextcharacterskin = Skins.Mario;
_cursor = MenuCursor.PlayGame;
_keyscursor = 1;
_skinscursor = 1;
}
public void SwitchToState(LevelState s)
{
this.state = s;
Debug.Log("LevelController is switching to state: " + this.state);
switch (this.state)
{
case LevelState.LOADIN:
this.SwitchToLoadIn();
break;
case LevelState.IDLE:
this.SwitchToIdle();
break;
case LevelState.WAITING:
this.SwitchToWaiting();
break;
case LevelState.PAUSED:
this.SwitchToPaused();
break;
case LevelState.LOADOUT:
this.SwitchToLoadOut();
break;
}
}
public void setZTimeLevel(MenuObject.ZombieTime mytime,LevelState myLevel)
{
if (myLevel == LevelState.Level2)
{
level2.setZTime(mytime);
}
else if (myLevel == LevelState.Level3)
{
level3.setZTime(mytime);
}
else if (myLevel == LevelState.Level4)
{
level4.setZTime(mytime);
}
else if (myLevel == LevelState.Level5)
{
level5.setZTime(mytime);
}
else if (myLevel == LevelState.Level6)
{
level6.setZTime(mytime);
}
}
protected void Awake()
{
LevelState = LevelState.Play;
GetComponent <EventBus>().On(EventFailed, () => StartCoroutine(OnLevelFailed()));
GetComponent <EventBus>().On(EventPass, () => StartCoroutine(OnLevelPass()));
}
private void HandleOnInfiniteGameOver()
{
state = LevelState.GAME_OVER;
UpdateAndSaveLevelData(true);
}
/// <summary>
/// Continua la partida
/// </summary>
private void ResumeGame()
{
Time.timeScale = lastTimeScale; //Constants.DEFAULT_TIME_SCALE;
state = isInitPause ? LevelState.INIT : LevelState.RUNNING;
isInitPause = false;
}
public BaseRoundDataVO(List <IRoundItem> items, List <IRoundItem> solutions, LevelState levelState, WarmUpState warmUpState, int timeout, int memorizeTimeout) : this(items, solutions, levelState, warmUpState, timeout)
{
MemorizeTimeout = memorizeTimeout;
}
// launched when idle time expires, waves attack
public void Fight()
{
currentState = LevelState.Combat;
}
void OnLevelComplete()
{
Utilities.Log("State ==> StatsScreen");
State = LevelState.StatsScreen;
HideHUDUI();
}
private void LoadData()
{
// load level data. In this demo, we generate the level data with code. In real game, you
// should load the level data.
var levelDataDictionary = new Dictionary <int, LevelData>();
for (int index = 1; index <= levelCount; index++)
{
var item = new LevelData();
item.levelID = index;
item.name = string.Format("Level {0:D2}", index);
levelDataDictionary.Add(item.levelID, item);
}
// load level state. In this demo, we generate the state with code. In real game, state
// should be restored from persistent data. When the state is updated, you should save it
// to persistent data.
var levelStateDictionary = new Dictionary <int, LevelState>();
for (int index = 1; index <= levelCount; index++)
{
var item = new LevelState();
item.levelID = index;
// set lock state
item.locked = index > (levelCount / 2);
if (item.locked)
{
item.starNumber = LevelStarNumber.None;
}
else
{
// set star number
item.starNumber = (LevelStarNumber)(index % 4);
// set score
item.score = index * 100;
}
// add it
levelStateDictionary.Add(item.levelID, item);
}
// set last unlocked level
int lastIndex = levelCount / 2;
var lastUnlockedLevel = levelStateDictionary[lastIndex];
lastUnlockedLevel.score = 0;
lastUnlockedLevel.starNumber = LevelStarNumber.None;
// create level info
currentLevelInfo = new LevelInfo();
// create level item list
levelItemList = new ObservableList <LevelItem>();
foreach (var kvp in levelStateDictionary)
{
var levelID = kvp.Key;
var levelState = kvp.Value;
// get level data
var levelData = levelDataDictionary[levelID];
// create level item
var newItem = new LevelItem(levelData, levelState);
// set command
newItem.SelectCommand = new DelegateCommand(() => SelectLevel(newItem));
// add it to list
levelItemList.Add(newItem);
}
// create level item dictionary
levelItemDictionary = new Dictionary <int, LevelItem>();
foreach (var item in levelItemList)
{
var key = item.LevelData.levelID;
levelItemDictionary.Add(key, item);
}
}
// start game method
public void StartGame()
{
// resets players, initializes to level 1, sets levelstate to playing
_player1.Reset();
computer.Reset();
if (myState == LevelState.Starting) _level = 1;
myState = LevelState.Playing;
// switches computers timedelay based on difficulty of game
switch (myDiff)
{
case Difficulty.Baby:
ComputerPlayer.timeDelay = 2 - (.1f * _level);
if (ComputerPlayer.timeDelay <= 0) Winner();
break;
case Difficulty.Easy:
ComputerPlayer.timeDelay = 1.2f - (.06f * _level);
if (ComputerPlayer.timeDelay <= 0) Winner();
break;
case Difficulty.Medium:
ComputerPlayer.timeDelay = .6f - (.03f * _level);
if (ComputerPlayer.timeDelay <= 0) Winner();
break;
case Difficulty.Hard:
ComputerPlayer.timeDelay = .44f - (.022f * _level);
if (ComputerPlayer.timeDelay <= 0) Winner();
break;
}
// makes new instance of speed between computer and player
speed = new Speed(deck, _background, _selector, _font, _player1, computer, _particles, Speed.gameType.Levels, shuffling, playingCard, shuffleInstance, isSoundOn, isPowerUpOn, isVibrateOn, freeze);
// sets level to level, turns speed on, makes player's state the playing state
speed.level = _level;
speed.TurnOn();
myState = LevelState.Playing;
// if player wins game, halts speed, increases level, and starts new game
speed.YouWon += delegate() { speed.isHalted = true; timer = new Timer(1); timer.SetTimer(0, 2, delegate() { _level++; StartGame(); }); };
// if player loses game, calls loser method, which prompts player to start new game or exit
speed.YouLost += delegate() { speed.isHalted = true; timer = new Timer(1); timer.SetTimer(0, 2, delegate() { Loser(); }); };
// if player ties computer, restarts game on the same level
speed.YouTie += delegate() { speed.isHalted = true; timer = new Timer(1); timer.SetTimer(0, 2, delegate() { StartGame(); }); };
}
public Level(int Num)
{
num = Num;
state = 0; //bloqueado
category = 'p'; //valor nulo por defecto
}
public Level(int Num, LevelState State)
{
num = Num;
state = State;
category = 'p'; //valor nulo por defecto
}
char category; //Familiar, Académico o Social
// -----Constructores----- //
public Level(int Num, LevelState State, char c)
{
num = Num;
state = State;
category = c;
}
public IOAPI(LevelState state)
{
m_state = state;
}
/// <summary>
/// Pausa la partida para el tutorial
/// </summary>
private void TutorialPauseFreeze()
{
lastTimeScale = Time.timeScale;
Time.timeScale = Constants.FREEZE_TIME_SCALE;
state = LevelState.TUTORIAL;
}
void Awake()
{
State = LevelState.Stop;
pointData = new PointerEventData(EventSystem.current);
}
//Changes the level state to the received state after time
IEnumerator ChangeStateAfter(LevelState newState, float time)
{
yield return(new WaitForSeconds(time));
levelState = newState;
}
private void HandleOnDeath()
{
state = LevelState.DEAD;
GM.AudioM.Raise_PlayerDeath();
}
public LevelItem(LevelData levelData, LevelState levelState)
{
this.levelData = levelData;
this.levelState = levelState;
}
public async Task SendMove(LevelState state)
{
await _connection.InvokeAsync(SendState, state);
}
// launched when collision with next level
public void Prepare()
{
currentState = LevelState.Preparation;
}
private void InitializeLevel()
{
_levelData = levelData[0];
emitState = EmitState.Regular;
levelState = LevelState.L1;
}
// Create temp level state
public static void SaveLevelState(int levelIndex, LevelState newLevelState)
{
TempLevelStates[levelIndex] = newLevelState;
}
public static BubbleQueue GetBubbleQueue(BubbleQueueType queueType,
LevelState levelState,
BubbleQueueDefinition definition)
{
return(typeMap[queueType](new QueueData(levelState, definition)));
}
public QueueData(LevelState state, BubbleQueueDefinition definition)
{
levelState = state;
bubbleQueueDefinition = definition;
}
private void HandleOnLevelStart()
{
state = LevelState.RUNNING;
Raise_StartTextTrigger();
}
public void setCurLevel(LevelState myLevel)
{
curLevel = myLevel;
}
/// <summary>
/// Pauses this <c>Level</c>.
/// </summary>
public void Pause()
{
if (State != LevelState.Running) {
SoomlaUtils.LogError(TAG, "Can't pause a level that is not running. state=" + State);
return;
}
long now = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
long now_ST = Mathf.RoundToInt(Time.time * 1000);
Elapsed += now - StartTime;
StartTime = 0;
Elapsed_ST += now_ST - StartTime_ST;
StartTime_ST = 0;
State = LevelState.Paused;
}
/// <summary>
/// Starts this <c>Level</c>.
/// </summary>
public bool Start()
{
if (State == LevelState.Running) {
SoomlaUtils.LogError(TAG, "Can't start a level that is already running. state=" + State);
return false;
}
SoomlaUtils.LogDebug(TAG, "Starting level with world id: " + _id);
if (!CanStart()) {
return false;
}
if (State != LevelState.Paused) {
Elapsed = 0;
Elapsed_ST = 0;
LevelStorage.IncTimesStarted(this);
}
StartTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
StartTime_ST = Mathf.RoundToInt(Time.time * 1000);
State = LevelState.Running;
return true;
}
private void HandleOnGameOver()
{
state = LevelState.GAME_OVER;
UpdateAndSaveLevelData(false);
}
/// <summary>
/// Ends this <c>Level</c>.
/// </summary>
/// <param name="completed">If set to <c>true</c> completed.</param>
public void End(bool completed)
{
// check end() called without matching start(),
// i.e, the level is not running nor paused
if(State != LevelState.Running && State != LevelState.Paused) {
SoomlaUtils.LogError(TAG, "end() called without prior start()! ignoring.");
return;
}
State = LevelState.Ended;
// Count number of times this level was played
LevelStorage.IncTimesPlayed(this);
if (completed) {
long duration = GetPlayDurationMillis();
// Calculate the slowest \ fastest durations of level play
if (duration > GetSlowestDurationMillis()) {
LevelStorage.SetSlowestDurationMillis(this, duration);
}
// We assume that levels' duration is never 0
long fastest = GetFastestDurationMillis();
if (fastest == 0 || duration < GetFastestDurationMillis()) {
LevelStorage.SetFastestDurationMillis(this, duration);
}
foreach (Score score in Scores.Values) {
score.Reset(true); // resetting scores
}
SetCompleted(true);
}
}
public LevelProgress()
{
LevelData = new LevelState[200];
LevelTimes = new float[200];
LevelData[0] = LevelState.Unlocked;
}
/// <summary>
/// Sets this <c>Level</c> as completed.
/// </summary>
/// <param name="completed">If set to <c>true</c> completed.</param>
public override void SetCompleted(bool completed)
{
if (completed) {
State = LevelState.Completed;
LevelStorage.IncTimesCompleted(this);
} else {
State = LevelState.Idle;
}
base.SetCompleted(completed);
}
private void CreateTree()
{
levelStates = new List <LevelState>();
char[] chars = lString.ToCharArray();
float currentRotation = 0;
float currentLength = startLength;
float currentWidth = startWidth;
Vector3 currentPosition = treeOrigin;
int levelIndex = 0;
LevelState levelState = new LevelState();
levelState.position = currentPosition;
levelState.levelIndex = levelIndex;
levelState.width = currentWidth;
levelState.length = currentLength;
levelState.rotation = currentRotation;
levelState.logicBranches = new List <LevelState.BranchState>();
levelStates.Add(levelState);
Vector3 tipPosition = new Vector3();
Queue <LevelState> savedStates = new Queue <LevelState>();
for (int i = 0; i < chars.Length; i++)
{
switch (chars[i])
{
case 'F':
if (levelState.levelIndex != levelIndex)
{
foreach (LevelState ls in levelStates)
{
if (ls.levelIndex == levelIndex)
{
levelState = ls;
break;
}
}
}
tipPosition.x = levelState.position.x + (currentLength * Mathf.Sin(Mathf.Deg2Rad * currentRotation));
tipPosition.y = levelState.position.y + (currentLength * Mathf.Cos(Mathf.Deg2Rad * currentRotation));
levelIndex++;
LevelState.BranchState branchState = new LevelState.BranchState();
branchState.rotation = currentRotation;
branchState.length = currentLength;
levelState.logicBranches.Add(branchState);
currentWidth *= widthDecreaseFactor;
currentPosition = tipPosition;
levelState = new LevelState();
levelState.position = currentPosition;
levelState.levelIndex = levelIndex;
levelState.width = currentWidth;
levelState.length = currentLength;
levelState.rotation = currentRotation;
levelState.logicBranches = new List <LevelState.BranchState>();
levelStates.Add(levelState);
currentLength *= lengthDecreaseFactor;
break;
case '+':
if (useRandomAngle)
{
currentRotation += Random.Range(angle - 5, angle + 5);
}
else
{
currentRotation += angle;
}
break;
case '-':
if (useRandomAngle)
{
currentRotation -= Random.Range(angle - 5, angle + 5);
}
else
{
currentRotation -= angle;
}
break;
case '[':
savedStates.Enqueue(levelState);
break;
case ']':
levelState = savedStates.Dequeue();
currentPosition = levelState.position;
currentRotation = levelState.rotation;
currentLength = levelState.length;
currentWidth = levelState.width;
levelIndex = levelState.levelIndex;
break;
}
}
for (int i = 0; i < levelStates.Count; i++)
{
levelState = levelStates[i];
int baseVertexPointer = vertices.Count;
for (int j = 0; j < levelState.logicBranches.Count; j++)
{
LevelState.BranchState bs = levelState.logicBranches[j];
Branch branch = new Branch(Vector3.zero, bs.length, levelState.width, bs.rotation, levelState.position, widthDecreaseFactor);
branches.Add(branch);
if (i == 0 && j == 0)
{
vertices.AddRange(branch.vertices);
faces.Add(baseVertexPointer);
faces.Add(baseVertexPointer + 1);
faces.Add(baseVertexPointer + 3);
faces.Add(baseVertexPointer + 3);
faces.Add(baseVertexPointer + 1);
faces.Add(baseVertexPointer + 2);
baseVertexPointer = vertices.Count;
}
else
{
int vertexPointer = vertices.Count;
vertices.Add(branch.vertices[1]);
vertices.Add(branch.vertices[2]);
Vector2Int vertexPointerXX = GetClosestVextexIndices(branch.vertices[0], branch.vertices[3], vertices, i);
faces.Add(vertexPointerXX.x);
faces.Add(vertexPointer);
faces.Add(vertexPointerXX.y);
faces.Add(vertexPointerXX.y);
faces.Add(vertexPointer);
faces.Add(vertexPointer + 1);
}
}
}
lTree.vertices = vertices.ToArray();
lTree.triangles = faces.ToArray();
lTree.RecalculateNormals();
Debug.Log("Tree has " + vertices.Count.ToString() + " vertices");
}
// method that changes level state to play again state, for use when human loses
public void Loser()
{
myState = LevelState.PlayAgain;
}
void Start()
{
levelState = LevelState.Begin;
}
public Level(int Num, char c)
{
num = Num;
state = 0; //bloqueado
category = c; //valor nulo por defecto
}
public void SetState(LevelState State)
{
state = State;
}
