void Start()
{
int temp = GetComponent <Player_Manager_PP_001>().GetPlayerID();
string temp2 = "StartPos" + temp.ToString();
startTransform = GameObject.Find(temp2).transform;
if (startTransform != null)
{
startingStates = StartStates.bootUp_1;
playerControll_Script.PlayWalkingAnimation(true);
myCamera.fieldOfView = 90.0f;
myCamera.transform.parent = startTransform.transform;
myCamera.transform.position = startTransform.GetChild(0).transform.position;
}
else
{
print("Could Not find this characters starting pos");
Destroy(this.gameObject);
}
children = playerCanvas.GetComponentsInChildren <Transform>();
for (int i = 1; i < children.Length; ++i)
{
children[i].gameObject.SetActive(false);
}
}
public void UpdateState3(string name, Color c)
{
print("This is the name " + name);
GetComponent <Player_Manager_PP_001>().SetPlayerName(name);
playerControll_Script.SetMannyColor(c);
startingStates = StartStates.begin_9;
}
private void StartState2_GolfMode()
{
if (ControllerTrigger > 0.0f)
{
startingStates = StartStates.golfUp_3;
InvokeRepeating("GolfUpSwitch", .1f, 0.5f);
}
}
/// <summary>
/// Add state to startstates
/// </summary>
/// <param name="state">The state</param>
public void DefineAsStartState(T state)
{
if (!DfaContainsState(state))
{
States.Add(state);
}
StartStates.Add(state);
}
public void DefineAsStartState(T t)
{
if (!States.Contains(t))
{
States.Add(t);
}
StartStates.Add(t);
}
private void StartState7_GunMode_2()
{
myCamera.GetComponent <PlayerCameraController>().CameraStartView(2.5f);
if (ControllerTrigger < 0.0f)
{
startingStates = StartStates.gunUp_8;
InvokeRepeating("GunUpSwitch", .1f, 0.5f);
}
}
private void StartState1_1_Camera()
{
myCamera.transform.parent = transform;
myCamera.transform.position = Vector3.MoveTowards(myCamera.transform.position, CameraAlivePosition.transform.position, 2.0f * Time.deltaTime);
if (myCamera.transform.position == CameraAlivePosition.transform.position)
{
startingStates = StartStates.golfUp_2;
playerControll_Script.PlayWalkingAnimation(false);
TurnOnACanvasChild(1, 2);
}
}
private void StartState9_BeginGame_1()
{
myCamera.GetComponent <PlayerCameraController>().CameraStartView(2.5f);
StartVanillaMode2();
CancelInvoke();
for (int i = 1; i < children.Length - 1; i++)
{
children[i].gameObject.SetActive(false);
}
TurnOnACanvasChild2(7, 7);
startingStates = StartStates.begin_10;
}
/// <summary>
/// Checks if input is valid, always returns false if ndfa
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public bool AcceptInputDfa(string input)
{
if (!IsDFA())
{
return(false);
}
char[] inputSymbols = input.ToCharArray();
foreach (char symbol in inputSymbols)
{
if (!Symbols.Contains(symbol))
{
return(false);
}
}
List <Transition <T> > startStatesTransitions = new List <Transition <T> >();
foreach (Transition <T> t in Transitions)
{
if (StartStates.Contains(t.FromState))
{
startStatesTransitions.Add(t);
}
}
T nextState1Temp = default(T);
foreach (Transition <T> state in startStatesTransitions)
{
if (state.Symbol == inputSymbols[0])
{
nextState1Temp = state.ToState;
break;
}
}
List <Transition <T> > nextState1 = new List <Transition <T> >();
foreach (Transition <T> t in Transitions)
{
if (t.FromState.Equals(nextState1Temp))
{
nextState1.Add(t);
}
}
return(true);
}
private void StartState1_WalkingUp()
{
float step = speed * Time.deltaTime;
transform.position = Vector3.MoveTowards(transform.position, startTransform.position, step);
myCamera.transform.position = Vector3.MoveTowards(myCamera.transform.position, startTransform.GetChild(1).transform.position, 5.0f * Time.deltaTime);
if (myCamera.fieldOfView > 55.0f)
{
myCamera.fieldOfView = myCamera.fieldOfView - 5.0f * Time.deltaTime;
}
if (transform.position == startTransform.position)
{
startingStates = StartStates.bootUp_1_1;
myCamera.transform.parent = transform;
}
}
/// <summary>
/// Generates a language with the given length. Language might be a tad suspciously the same everytime due to the exclusion of rng
/// </summary>
/// <param name="length">The length of the string to generate</param>
/// <returns>An error string if the string can't be generated and a word if there is a valid word with the given value</returns>
public string GenerateLanguageOfGivenLength(int length)
{
string initialString = "";
string errorString = "Problem encountered so no valid language could be generated.";
if (length < GetMinimumLanguageLength())
{
return(errorString);
} //Early return for when the given length is shorter than the lenght of the shortest word
Random rng = new Random();
T startState = StartStates.ElementAt(rng.Next(0, (StartStates.Count - 1))); //Substracting one to prevent out of bounds errors
string result = AddLetterToLanguage(length, initialString, startState);
result = String.IsNullOrEmpty(result) ? errorString : result;
return(result);
}
private void StartState3_GolfSwing()
{
if (ControllerTrigger > 0.0f)
{
playerControll_Script.RunTranslate();
//payerCurrentState = PlayerStatus.GolfFree;
//myCamera.GetComponent<PlayerCameraController>().CameraGolfFree();
myCamera.GetComponent <PlayerCameraController>().CameraGolfFree_Start();
playerControll_Script.RunGolfFreeState();
clubWeapon_Script.GolfMode();
float curSwing = Input.GetAxis("CameraVertical");
if (curSwing < 0.0f)
{
TurnOffACanvasChild();
startingStates = StartStates.golfHit_4;
}
}
else
{
StartVanillaMode();
}
}
public bool addStartState(T state)
{
return(StartStates.Add(state));
}
public Tuple <IReadOnlyDictionary <State, State>, DFA <TData> > Minimize(Func <State, State, bool> areEquivalent, Func <TData, TData, TData> combine)
{
var transitionList = MakeTransitionsList();
var blocks = new Partition(StateCount);
// Reachable from start
foreach (var startState in StartStates)
{
blocks.Mark(startState.Index);
}
DiscardNotReachable(blocks, transitionList, t => t.From, t => t.To);
// Reachable from final
var finalStates = States.Where(IsFinal).ToList();
foreach (var finalState in finalStates)
{
blocks.Mark(finalState.Index);
}
DiscardNotReachable(blocks, transitionList, t => t.To, t => t.From);
// Split final states from non-final
foreach (var finalState in finalStates)
{
blocks.Mark(finalState.Index);
}
blocks.SplitSets();
// Split final states from other non-equivalent final states
var possibleEquivalentStates = finalStates;
while (possibleEquivalentStates.Any())
{
var state = possibleEquivalentStates.First();
var equivalentStatesLookup = possibleEquivalentStates.Skip(1).ToLookup(s => areEquivalent(state, s));
// Mark states
blocks.Mark(state.Index);
foreach (var finalState in equivalentStatesLookup[true])
{
blocks.Mark(finalState.Index);
}
blocks.SplitSets();
possibleEquivalentStates = equivalentStatesLookup[false].ToList();
}
// Cords partition to manage transitions
var cords = new Partition(transitionList.Count);
// Sort transitions by input
cords.PartitionBy(transition => transitionList[transition].OnInput);
//Split blocks and cords
var adjacentTransitions = new AdjacentTransitions(StateCount, transitionList, t => t.To);
var blockSet = 1;
for (var cordSet = 0; cordSet < cords.SetCount; cordSet++)
{
foreach (var transition in cords.Set(cordSet))
{
blocks.Mark(transitionList[transition].From);
}
blocks.SplitSets();
for (; blockSet < blocks.SetCount; blockSet++)
{
foreach (var state in blocks.Set(blockSet))
{
foreach (var transition in adjacentTransitions[state])
{
cords.Mark(transition);
}
}
cords.SplitSets();
}
}
// Generate minimized DFA
var minDFA = new DFA <TData>(InputValueCount, blocks.SetCount);
// Create states
for (var set = 0; set < blocks.SetCount; set++)
{
var data = blocks.Set(set).Select(s => GetData(new State(s))).Aggregate(combine);
var state = minDFA.AddState(data);
// Sets are either all final or non-final states
if (IsFinal(new State(blocks.SomeElementOf(set))))
{
minDFA.SetFinal(state);
}
}
// Create Start State Map
var startStateMap = (IReadOnlyDictionary <State, State>)StartStates.ToDictionary(s => s, s => new State(blocks.SetOf(s.Index)));
// Mark Start States
foreach (var startState in startStateMap.Values)
{
minDFA.SetStart(startState);
}
// Create transitions
for (var set = 0; set < cords.SetCount; set++)
{
var transition = transitionList[cords.SomeElementOf(set)];
var from = new State(blocks.SetOf(transition.From));
var to = new State(blocks.SetOf(transition.To));
minDFA.SetTransition(from, new Input(transition.OnInput), to);
}
return(Tuple.Create(startStateMap, minDFA));
}
//sets the grid to a previous state
public void ResetGrid()
{
StartStates.CopyTo(CurrentStates, 0);
}
public void UpdateState2()
{
startingStates = StartStates.gunUp_6;
}
public void UpdateState()
{
startingStates = StartStates.gunUp_5;
myCamera.cullingMask &= ~(1 << LayerMask.NameToLayer("PointLights"));
}
private void StartState6_GunMode_1()
{
startingStates = StartStates.gunUp_7;
StartVanillaMode2();
TurnOnACanvasChild2(5, 5);
}
public void DefineAsStartState(T state)
{
States.Add(state);
StartStates.Add(state);
}
