public void Render(TypePhase phase)
{
if (TurnPlayerManager.instance.IsAllPlayerDead())
{
return;
}
if (!(phase == TypePhase.EndDayPhase))
{
phasePanel.SetActive(true);
}
switch (phase)
{
case TypePhase.DayPhase:
RenderDayPhase();
break;
case TypePhase.ActionPhase:
RenderActionPhase();
break;
case TypePhase.StatusPhase:
RenderStatusPhase();
break;
case TypePhase.NightPhase:
RenderNightPhase();
break;
case TypePhase.EndDayPhase:
RenderChangeDayPhase();
break;
}
}
public void BindUsage(ISeq <JST.Statement> statements, CST.Usage usage, TypePhase typePhase)
{
foreach (var kv in usage.Assemblies)
{
if (kv.Value > 1)
{
if (!boundAssemblies.ContainsKey(kv.Key))
{
var e = env.JSTHelpers.DefaultResolveAssembly(this, kv.Key);
if (e != null)
{
if (env.DebugMode)
{
statements.Add(new JST.CommentStatement(kv.Key.ToString()));
}
var id = NameSupply.GenSym();
statements.Add(JST.Statement.Var(id, e));
boundAssemblies.Add(kv.Key, id.ToE());
}
}
// else: use outer binding
}
// else: inline expression as need it
}
foreach (var kv in usage.Types)
{
if (kv.Value > 1)
{
var existing = default(ExpressionAndPhase);
var b = boundTypes.TryGetValue(kv.Key, out existing);
if (!b || typePhase > existing.Phase)
{
var e = env.JSTHelpers.DefaultResolveType(this, kv.Key, typePhase);
if (e != null)
{
if (env.DebugMode)
{
statements.Add(new JST.CommentStatement(kv.Key.ToString()));
}
var id = NameSupply.GenSym();
statements.Add(JST.Statement.Var(id, e));
var updated = new ExpressionAndPhase(id.ToE(), typePhase);
if (b)
{
boundTypes[kv.Key] = updated;
}
else
{
boundTypes.Add(kv.Key, updated);
}
}
}
// else: use outer binding
}
// else: inline expression as need it
}
}
//------------------------------------------------------------------------
public bool IsDefiniPar(IDefinisseurEvenements definisseur)
{
if (TypePhase == null || !(definisseur is CTypePhase))
{
return(false);
}
if (TypePhase.Equals(definisseur))
{
return(true);
}
return(false);
}
// ----------------------------------------------------------------------
// Types
// ----------------------------------------------------------------------
public JST.Expression ResolveType(CST.TypeRef typeRef, TypePhase typePhase)
{
var groundTypeRef = SubstituteType(typeRef);
var existing = default(ExpressionAndPhase);
if (boundTypes.TryGetValue(groundTypeRef, out existing) && typePhase <= existing.Phase)
{
return(existing.Expression);
}
else
{
return(env.JSTHelpers.DefaultResolveType(this, groundTypeRef, typePhase));
}
}
// ----------------------------------------------------------------------
// Types
// ----------------------------------------------------------------------
public JST.Expression ResolveType(CST.TypeRef typeRef, TypePhase typePhase)
{
var groundTypeRef = SubstituteType(typeRef);
var res = default(JST.Expression);
if (typePhase <= TypePhase.Constructed && boundTypes.TryGetValue(groundTypeRef, out res))
{
return(res);
}
else
{
return(env.JSTHelpers.DefaultResolveType(this, groundTypeRef, TypePhase.Constructed));
}
}
public ExpressionAndPhase(JST.Expression expression, TypePhase phase)
{
Expression = expression;
Phase = phase;
}
// ----------------------------------------------------------------------
// Types
// ----------------------------------------------------------------------
public JST.Expression ResolveType(CST.TypeRef typeRef, TypePhase typePhase)
{
var groundTypeRef = SubstituteType(typeRef);
var existing = default(ExpressionAndPhase);
if (boundTypes.TryGetValue(groundTypeRef, out existing) && typePhase <= existing.Phase)
return existing.Expression;
else
return env.JSTHelpers.DefaultResolveType(this, groundTypeRef, typePhase);
}
public void BindUsage(ISeq<JST.Statement> statements, CST.Usage usage, TypePhase typePhase)
{
foreach (var kv in usage.Assemblies)
{
if (kv.Value > 1)
{
if (!boundAssemblies.ContainsKey(kv.Key))
{
var e = env.JSTHelpers.DefaultResolveAssembly(this, kv.Key);
if (e != null)
{
if (env.DebugMode)
statements.Add(new JST.CommentStatement(kv.Key.ToString()));
var id = NameSupply.GenSym();
statements.Add(JST.Statement.Var(id, e));
boundAssemblies.Add(kv.Key, id.ToE());
}
}
// else: use outer binding
}
// else: inline expression as need it
}
foreach (var kv in usage.Types)
{
if (kv.Value > 1)
{
var existing = default(ExpressionAndPhase);
var b = boundTypes.TryGetValue(kv.Key, out existing);
if (!b || typePhase > existing.Phase)
{
var e = env.JSTHelpers.DefaultResolveType(this, kv.Key, typePhase);
if (e != null)
{
if (env.DebugMode)
statements.Add(new JST.CommentStatement(kv.Key.ToString()));
var id = NameSupply.GenSym();
statements.Add(JST.Statement.Var(id, e));
var updated = new ExpressionAndPhase(id.ToE(), typePhase);
if (b)
boundTypes[kv.Key] = updated;
else
boundTypes.Add(kv.Key, updated);
}
}
// else: use outer binding
}
// else: inline expression as need it
}
}
public ExpressionAndPhase(JST.Expression expression, TypePhase phase)
{
Expression = expression;
Phase = phase;
}
public JST.Expression ResolveType(CST.TypeRef typeRef, TypePhase typePhase)
{
return(Env.JSTHelpers.DefaultResolveType(this, typeRef, typePhase));
}
public JST.Expression ResolveType(CST.TypeRef typeRef, TypePhase typePhase)
{
return Env.JSTHelpers.DefaultResolveType(this, typeRef, typePhase);
}
