public static ITimeable BuildTimeTernary(List <Token> tokens)
{
IBoolable condition = BoolableBuilder.Build(GetTernaryCondition(tokens));
if (condition.IsNull())
{
return(null);
}
ITimeable confirmationCase = TimeableBuilder.Build(GetTernaryConfirmation(tokens));
if (confirmationCase.IsNull())
{
return(null);
}
ITimeable negationCase = TimeableBuilder.Build(GetTernaryNegation(tokens));
if (negationCase.IsNull())
{
return(null);
}
return(new TimeTernary(condition, confirmationCase, negationCase));
}
public static IBoolable BuildTimTim(string name, List <Argument> args)
{
if (args.Count != 2)
{
throw new SyntaxErrorException("ERROR! Function " + name + " has to have 2 time arguments.");
}
ITimeable itim1 = TimeableBuilder.Build(args[0].tokens);
ITimeable itim2 = TimeableBuilder.Build(args[1].tokens);
if (itim1.IsNull())
{
throw new SyntaxErrorException("ERROR! First argument of function " + name + " cannot be read as time.");
}
if (itim2.IsNull())
{
throw new SyntaxErrorException("ERROR! Second argument of function " + name + " cannot be read as time.");
}
if (name.Equals("samedate") || name.Equals("samedates") ||
name.Equals("thesamedate") || name.Equals("thesamedates"))
{
return(new FuncSamedates(itim1, itim2));
}
else if (name.Equals("sameclock") || name.Equals("sameclocks") ||
name.Equals("thesameclock") || name.Equals("thesameclocks"))
{
return(new FuncSamedates(itim1, itim2));
}
throw new SyntaxErrorException("ERROR! Function " + name + " not identified.");
}
private static ITimeable BuildFromDateAndClock(List <Token> tokens)
{
List <Token> beforeComma = new List <Token>();
List <Token> afterComma = new List <Token>();
int level = 0;
bool pastComma = false;
foreach (Token tok in tokens)
{
if (tok.GetTokenType().Equals(TokenType.BracketOn))
{
level++;
}
if (tok.GetTokenType().Equals(TokenType.BracketOff))
{
level--;
}
if (tok.GetTokenType().Equals(TokenType.Comma) && level == 0)
{
pastComma = true;
}
else
{
if (pastComma)
{
afterComma.Add(tok);
}
else
{
beforeComma.Add(tok);
}
}
}
ITimeable itim = TimeableBuilder.Build(beforeComma);
if (itim.IsNull())
{
return(null);
}
IClock clock = BuildClock(afterComma);
if (clock.IsNull())
{
return(null);
}
if (itim is Time)
{
(itim as Time).SetNewClock(clock);
return(itim);
}
else
{
return(new TimeableWithClock(itim, clock));
}
}
public void CmdIncreaseTime(float value)
{
// Tells the server to increase the time by value
Debug.Log(" Server sending command to increase time");
if (timer == null)
{
timer = GameObject.FindObjectOfType <UpdateTime> ();
}
timer.IncreaseTime(value);
}
// Use this for initialization
void Start()
{
if (isLocalPlayer)
{
GameObject.FindObjectOfType <StashButtonController> ().player = this.gameObject;
}
justDropped = null;
timer = GameObject.FindObjectOfType <UpdateTime> ();
spriteRenderer = gameObject.GetComponent <SpriteRenderer> ();
profileContainer = gameObject.GetComponent <PlayerProfileContainer> ();
playerScore = gameObject.GetComponent <PlayerScore> ();
}
IEnumerator CoWaitForBeats(ITimeable timeable, int count)
{
int beats = timing.beatCount;
int endBeats = beats + count;
while (beats < endBeats)
{
beats = timing.beatCount;
yield return(null);
}
timeable.OnBeatsElapsed();
}
private static IBoolable BuildBetweenTimes(ITimeable tim, List <Token> left, List <Token> right)
{
ITimeable timLeft = TimeableBuilder.Build(left);
ITimeable timRight = TimeableBuilder.Build(right);
if (timLeft.IsNull() || timRight.IsNull())
{
return(null);
}
else
{
return(new BetweenTimes(tim, timLeft, timRight));
}
}
private static ICommand BuildComplex(TokenType type, IListable list, ITimeable time)
{
switch (type)
{
case TokenType.Recreate:
return(new RecreateTo(list, time));
case TokenType.Remodify:
return(new RemodifyTo(list, time));
case TokenType.Reaccess:
return(new ReaccessTo(list, time));
}
throw new SyntaxErrorException("ERROR! Command not indentified."); // this is never thrown
}
private static ICommand BuildSimple(TokenType type, ITimeable time)
{
switch (type)
{
case TokenType.Recreate:
return(new RecreateTo(new StringVariableRefer("this"), time));
case TokenType.Remodify:
return(new RemodifyTo(new StringVariableRefer("this"), time));
case TokenType.Reaccess:
return(new ReaccessTo(new StringVariableRefer("this"), time));
}
throw new SyntaxErrorException("ERROR! Command not indentified."); // this is never thrown
}
private IEnumerator DecrementTimer(int seconds, ITimeable callback)
{
this.seconds = seconds;
callback.OnStartTimer();
while (this.seconds > 0)
{
yield return(new WaitForSeconds(1f));
this.seconds--;
callback.OnIncrementTimer();
}
callback.OnFinishTimer();
}
public static INumerable BuildTimTim(string name, List <Argument> args)
{
if (args.Count != 2)
{
throw new SyntaxErrorException("ERROR! Function " + name + " has to have 2 time arguments.");
}
ITimeable itim1 = TimeableBuilder.Build(args[0].tokens);
ITimeable itim2 = TimeableBuilder.Build(args[1].tokens);
if (itim1.IsNull())
{
throw new SyntaxErrorException("ERROR! First argument of function " + name + " cannot be read as time.");
}
if (itim2.IsNull())
{
throw new SyntaxErrorException("ERROR! Second argument of function " + name + " cannot be read as time.");
}
if (name.Equals("yearsbetween"))
{
return(new Func__TimeBetween(itim1, itim2, TimeVariableType.Year));
}
else if (name.Equals("monthsbetween"))
{
return(new Func__TimeBetween(itim1, itim2, TimeVariableType.Month));
}
else if (name.Equals("daysbetween"))
{
return(new Func__TimeBetween(itim1, itim2, TimeVariableType.Day));
}
else if (name.Equals("hoursbetween"))
{
return(new Func__TimeBetween(itim1, itim2, TimeVariableType.Hour));
}
else if (name.Equals("minutesbetween"))
{
return(new Func__TimeBetween(itim1, itim2, TimeVariableType.Minute));
}
else if (name.Equals("secondsbetween"))
{
return(new Func__TimeBetween(itim1, itim2, TimeVariableType.Second));
}
throw new SyntaxErrorException("ERROR! Function " + name + " not identified.");
}
private static IBoolable BuildBetween(List <Token> tokens)
{
int betweenIndex = TokenGroups.IndexOfTokenOutsideBrackets(tokens, TokenType.Between);
int andIndex = TokenGroups.IndexOfTokenOutsideBrackets(tokens, TokenType.And);
if (andIndex < betweenIndex)
{
return(null);
}
if (betweenIndex == andIndex - 1)
{
throw new SyntaxErrorException("ERROR! Expression 'between' do not contain definition of value of left boundary.");
}
if (betweenIndex == 0)
{
throw new SyntaxErrorException("ERROR! Expression 'between' starts with keyword 'between' and thus do not contain comparing value.");
}
if (andIndex == tokens.Count - 1)
{
throw new SyntaxErrorException("ERROR! Expression 'between' ends with keyword 'and' and thus do not contain definition of value of right boundary.");
}
List <Token> valueTokens = tokens.Take(betweenIndex).ToList();
List <Token> leftTokens = tokens.GetRange(betweenIndex + 1, andIndex - betweenIndex - 1);
List <Token> rightTokens = tokens.Skip(andIndex + 1).ToList();
INumerable inum = NumerableBuilder.Build(valueTokens);
if (!inum.IsNull())
{
return(BuildBetweenNumbers(inum, leftTokens, rightTokens));
}
ITimeable itim = TimeableBuilder.Build(valueTokens);
if (!itim.IsNull())
{
return(BuildBetweenTimes(itim, leftTokens, rightTokens));
}
return(null);
}
public static INumerable BuildTim(string name, List <Argument> args)
{
if (args.Count != 1)
{
throw new SyntaxErrorException("ERROR! Function " + name + " has to have 1 time argument.");
}
ITimeable itim = TimeableBuilder.Build(args[0].tokens);
if (itim.IsNull())
{
throw new SyntaxErrorException("ERROR! Argument of function " + name + " cannot be read as time.");
}
if (name.Equals("yearday") || name.Equals("dayofyear"))
{
return(new FuncYearday(itim));
}
throw new SyntaxErrorException("ERROR! Function " + name + " not identified.");
}
private static IBoolable BuildTimeComparison(List <Token> tokens)
{
int index = tokens.TakeWhile(x => !TokenGroups.IsTimeComparingSign(x.GetTokenType())).Count();
if (index == 0 || index == tokens.Count - 1)
{
return(null);
}
ComparisonType type = tokens[index].GetTokenType().Equals(TokenType.IsAfter) ? ComparisonType.Bigger : ComparisonType.Smaller;
List <Token> leftTokens = tokens.GetRange(0, index);
List <Token> rightTokens = tokens.GetRange(index + 1, tokens.Count - index - 1);
ITimeable leftL = TimeableBuilder.Build(leftTokens);
ITimeable rightL = TimeableBuilder.Build(rightTokens);
if (leftL.IsNull() || rightL.IsNull())
{
return(null);
}
return(new TimeComparison(leftL, rightL, type));
}
public static ITimeable BuildRelativeTime(List <Token> tokens)
{
List <RelativeTimeStruct> relativeTimes = new List <RelativeTimeStruct>();
List <Token> currentTokens = new List <Token>();
foreach (Token tok in tokens)
{
currentTokens.Add(tok);
if (IsTimeDirection(tok))
{
List <RelativeTimeStruct> rtss = BuildRelativeTimeStructs(currentTokens.Take(currentTokens.Count - 1).ToList(), currentTokens.Last());
if (rtss.IsNull())
{
return(null);
}
else
{
relativeTimes.AddRange(rtss);
}
currentTokens.Clear();
}
}
if (currentTokens.Count == 0)
{
throw new SyntaxErrorException("ERROR! Relative time expression do not have definition for reference time.");
}
ITimeable itim = TimeableBuilder.Build(currentTokens);
if (itim.IsNull())
{
return(null);
}
return(new RelativeTimeExpression(relativeTimes, itim));
}
public FuncSamedates(ITimeable arg0, ITimeable arg1)
{
this.arg0 = arg0;
this.arg1 = arg1;
}
public static ICommand Build(List <Token> tokens)
{
TokenType type = tokens[0].GetTokenType();
string name = type.Equals(TokenType.Recreate) ? "recreate" : (type.Equals(TokenType.Remodify) ? "remodify" : "reaccess");
tokens.RemoveAt(0);
if (tokens.Where(t => t.GetTokenType().Equals(TokenType.To)).Count() > 1)
{
throw new SyntaxErrorException("ERROR! In " + name + " command keyword 'to' occurs too many times.");
}
List <Token> part1 = new List <Token>();
List <Token> part2 = new List <Token>();
bool pastTo = false;
foreach (Token tok in tokens)
{
if (tok.GetTokenType().Equals(TokenType.To))
{
pastTo = true;
}
else
{
if (pastTo)
{
part2.Add(tok);
}
else
{
part1.Add(tok);
}
}
}
if (part2.Count == 0)
{
throw new SyntaxErrorException("ERROR! Command " + name + " is too short and do not contain all necessary information.");
}
ITimeable expression2 = TimeableBuilder.Build(part2);
if (expression2.IsNull())
{
throw new SyntaxErrorException("ERROR! Second part of command " + name + " cannot be read as time.");
}
if (part1.Count == 0)
{
return(BuildSimple(type, expression2));
}
else
{
IListable expression1 = ListableBuilder.Build(part1);
if (expression1.IsNull())
{
throw new SyntaxErrorException("ERROR! First part of command " + name + " cannot be read as list.");
}
return(BuildComplex(type, expression1, expression2));
}
}
public void Attach(ITimeable timeable)
{
this.timeables.Add(timeable);
}
public IEnumerator StartTimerCouroutine(int seconds, ITimeable callback)
{
couroutine = DecrementTimer(seconds, callback);
return(couroutine);
}
public static ICommand Build(List <Token> tokens)
{
string name = tokens[0].GetContent();
tokens.RemoveAt(0);
tokens.RemoveAt(0);
if (tokens.Count == 0)
{
throw new SyntaxErrorException("ERROR! Variable " + name + " has no assigned value.");
}
if (name.Contains('.'))
{
return(BuildWithPoint(tokens, name));
}
if (!InterVariables.GetInstance().Contains(name))
{
IListable value = ListableBuilder.Build(tokens);
if (value.IsNull())
{
throw new SyntaxErrorException("ERROR! There are is something wrong with assigning value to variable " + name + ".");
}
if (value is IBoolable)
{
InterVariables.GetInstance().Add(name, InterVarType.Bool);
return(new BoolDeclaration(name, (IBoolable)value));
}
else if (value is INumerable)
{
InterVariables.GetInstance().Add(name, InterVarType.Number);
return(new NumericDeclaration(name, (INumerable)value));
}
else if (value is ITimeable)
{
InterVariables.GetInstance().Add(name, InterVarType.Time);
return(new TimeDeclaration(name, (ITimeable)value));
}
else if (value is IStringable)
{
InterVariables.GetInstance().Add(name, InterVarType.String);
return(new StringDeclaration(name, (IStringable)value));
}
else
{
InterVariables.GetInstance().Add(name, InterVarType.List);
return(new ListDeclaration(name, value));
}
}
else
{
InterVar ivar = InterVariables.GetInstance().GetVar(name);
if (ivar.IsBool())
{
IBoolable value = BoolableBuilder.Build(tokens);
if (value.IsNull())
{
throw new SyntaxErrorException("ERROR! Value assigned to variable " + name + " must be logical.");
}
return(new BoolDeclaration(name, value));
}
else
{
if (ivar.IsNumber())
{
INumerable value = NumerableBuilder.Build(tokens);
if (value.IsNull())
{
throw new SyntaxErrorException("ERROR! Value assigned to variable " + name + " must be numeric.");
}
return(new NumericDeclaration(name, value));
}
else if (ivar.IsTime())
{
ITimeable value = TimeableBuilder.Build(tokens);
if (value.IsNull())
{
throw new SyntaxErrorException("ERROR! Value assigned to variable " + name + " must be time.");
}
return(new TimeDeclaration(name, value));
}
else if (ivar.IsString())
{
IStringable value = StringableBuilder.Build(tokens);
if (value.IsNull())
{
throw new SyntaxErrorException("ERROR! Value assigned to variable " + name + " must be text.");
}
return(new StringDeclaration(name, value));
}
else
{
IListable value = ListableBuilder.Build(tokens);
if (value.IsNull())
{
throw new SyntaxErrorException("ERROR! Value assigned to variable " + name + " must be list.");
}
return(new ListDeclaration(name, value));
}
}
}
}
public RecreateTo(IListable list, ITimeable newTime)
{
this.list = list;
this.newTime = newTime;
}
public RemodifyTo(IListable list, ITimeable newTime)
{
this.list = list;
this.newTime = newTime;
}
public void Detach(ITimeable timeable)
{
this.timeables.Remove(timeable);
}
public static ITimeable Build(List <Token> tokens)
{
// remove first and last bracket if it is there
while (tokens[0].GetTokenType().Equals(TokenType.BracketOn) && tokens[tokens.Count - 1].GetTokenType().Equals(TokenType.BracketOff) &&
!Brackets.ContainsIndependentBracketsPairs(tokens, BracketsType.Normal))
{
List <Token> tokensCopy = tokens.Select(t => t.Clone()).ToList();
tokensCopy.RemoveAt(tokens.Count - 1);
tokensCopy.RemoveAt(0);
tokens = tokensCopy;
}
// try to build simple one-token Timeable
if (tokens.Count == 1)
{
if (tokens[0].GetTokenType().Equals(TokenType.Variable))
{
string str = tokens[0].GetContent();
if (InterVariables.GetInstance().Contains(str, InterVarType.Time))
{
return(new TimeVariableRefer(str));
}
}
}
//try to build time function
if (Functions.IsPossibleFunction(tokens))
{
ITimeable itim = TimeFunction.Build(tokens);
if (!itim.IsNull())
{
return(itim);
}
}
// try to build time ternary
if (TernaryBuilder.IsPossibleTernary(tokens))
{
ITimeable itim = TernaryBuilder.BuildTimeTernary(tokens);
if (!itim.IsNull())
{
return(itim);
}
}
// try to build relative time expression
if (tokens.Where(t => IsTimeDirection(t)).Count() > 0)
{
ITimeable itim = BuildRelativeTime(tokens);
if (!itim.IsNull())
{
return(itim);
}
}
if (HasOneComma(tokens))
{
// try to build Timeable from date and clock
ITimeable itim = BuildFromDateAndClock(tokens);
if (!itim.IsNull())
{
return(itim);
}
}
else
{
// try to build Timeable from date only
if (ContainMonth(tokens))
{
ITimeable itim = BuildFromDate(tokens);
if (!itim.IsNull())
{
return(itim);
}
}
// try to build Timeable from clock only
if (ContainSemicolons(tokens))
{
ITimeable itim = BuildFromClock(tokens);
if (!itim.IsNull())
{
return(itim);
}
}
}
return(null);
}
public TimeDeclaration(string name, ITimeable value)
{
this.name = name;
this.value = value;
}
public static bool IsReady(ITimeable c) => c.CT >= ActionAmount;
public ReaccessTo(IListable list, ITimeable newTime)
{
this.list = list;
this.newTime = newTime;
}
public BetweenTimes(ITimeable value, ITimeable leftBound, ITimeable rightBound)
{
this.value = value;
this.leftBound = leftBound;
this.rightBound = rightBound;
}
public TimeComparison(ITimeable leftSide, ITimeable rightSide, ComparisonType type)
{
this.leftSide = leftSide;
this.rightSide = rightSide;
this.type = type;
}
public TimeTernary(IBoolable condition, ITimeable leftValue, ITimeable rightValue)
{
this.condition = condition;
this.leftValue = leftValue;
this.rightValue = rightValue;
}
