void Start()
{
Active = false;
myRenderer = this.GetComponent <Renderer>();
storedPosition = transform.position;
AllPoints.Add(this, storedPosition);
CallProvider.AddPeriodicUpdateListener(this.PeriodicUpdate);
}
private WebRtcAdapter.Call.Call SetCall()
{
ICallProvider callFactory =
ClientCore.Factory.CallFactory.Singleton.CreateICallProvider();
CallProvider callProvider = (CallProvider)callFactory;
return((WebRtcAdapter.Call.Call)callProvider.GetCall());
}
void OnDestroy()
{
AllPoints.Remove(this, storedPosition);
if (CallProvider.CanAccessInstance)
{
CallProvider.RemovePeriodicUpdateListener(this.PeriodicUpdate);
}
}
private void DoUpdate()
{
if (Time.time <= lastStep + RevelationSpeed)
{
return;
}
lastStep += RevelationSpeed;
foreach (var cell in prevCells)
{
if (!cell.IsNude || cell.IsBomb)
{
continue;
}
foreach (var neighbor in cell.Neighbors)
{
if (neighbor.State == CellState.Default)
{
neighbor.State = CellState.Revealed;
if (neighbor.IsNude && !neighbor.IsBomb)
{
buffer.Add(neighbor);
}
}
}
}
if (buffer.Count == 0)
{
IsFinished = true;
foreach (var action in followupActions)
{
action.Invoke();
}
OnFinished();
GlobalListPool <BoardCell> .Put(prevCells);
GlobalListPool <BoardCell> .Put(buffer);
GlobalListPool <Action> .Put(followupActions);
CallProvider.RemoveUpdateListener(DoUpdate);
return;
}
var tmp = prevCells;
prevCells = buffer;
buffer = tmp;
buffer.Clear();
}
public CallViewerForm()
{
InitializeComponent();
storage = new CallStorage();
storage.CallAdded += RefreshCallListView;
callProvider = new CallProvider(storage);
callProvider.StartGenerateCalls();
}
public Form1()
{
InitializeComponent();
lock_obj = new object();
callList = new List <CallViewModel>();
storage = new CallStorage();
storage.CallAdded += ReshrechCallView;
provider = new CallProvider(storage);
provider.Stast();
}
public Revelation(Board board, BoardCell cell, float revelationSpeed)
{
this.prevCells = GlobalListPool <BoardCell> .Get();
this.buffer = GlobalListPool <BoardCell> .Get();
this.followupActions = GlobalListPool <Action> .Get();
this.RevelationSpeed = revelationSpeed;
this.board = board;
cell.State = CellState.Revealed;
prevCells.Add(cell);
lastStep = Time.time;
CallProvider.AddUpdateListener(DoUpdate);
}
/// <summary>
/// Initializes a new instance of the <see cref="AddCallTransformation"/> class.
/// </summary>
/// <param name="provider">Call provider that will be asked for call definition.</param>
public AddCallTransformation(CallProvider provider)
{
_provider = provider;
}
/// <summary>
/// Create edit for call creation.
/// </summary>
/// <param name="name">The name of edit.</param>
/// <param name="callProvider">The provider of created call.</param>
/// <returns>Created edit.</returns>
protected Edit AddCallEdit(string name, CallProvider callProvider)
{
return(Edits.AddCall(This, name, callProvider));
}
/// <summary>
/// Creates edit that creates specified call.
/// </summary>
/// <param name="editProvider">The edit provider.</param>
/// <param name="editName">Name of the edit.</param>
/// <param name="callProvider">The call provider.</param>
/// <returns>Created edit.</returns>
public Edit AddCall(Instance editProvider, string editName, CallProvider callProvider)
{
var transformation = new AddCallTransformation(callProvider);
return(AddEdit(editProvider, editName, transformation));
}
private static Task <object> CallHelper(CallProvider reflectCallProvider, string method, byte[] param)
{
return(reflectCallProvider.ProcessCall(new { method, param }));
}
/// <summary>
/// Register call provider for given node
/// </summary>
/// <param name="callNode">Node corresponding to given call provider</param>
/// <param name="callProvider">Registered call provider</param>
internal void RegisterCallProvider(INodeAST callNode, CallProvider callProvider)
{
_callProviders[callNode] = callProvider;
}
protected virtual Expression VisitMethod(CommonTree tree, Expression inner)
{
// Calc param types
var parameters = new Expression[tree.ChildCount - 1];
var types = new Type[parameters.Length];
for (int i = 1; i < tree.ChildCount; i++)
{
parameters[i - 1] = Visit((CommonTree)tree.Children[i]);
types[i - 1] = parameters[i - 1].Type;
}
var methodName = GetMethodName(tree, inner == null);
Member member = null;
Expression callOn = null;
if (inner == null)
{
// Parameters
var param = Parameters.Where(p => p.Name == methodName).FirstOrDefault();
if (param != null)
{
return(param);
}
// Find method on this
if (This != null)
{
member = CallProvider.FindMethod(This.Type, methodName, types);
if (member != null)
{
callOn = This;
}
}
// Static method
if (member == null)
{
member = CallProvider.FindMethod(null, methodName, types);
}
}
else
{
// Instance method
member = CallProvider.FindMethod(inner.Type, methodName, types);
if (member != null)
{
callOn = inner;
}
}
if (member == null)
{
if (tree.Parent == null || tree.Parent.Type != FormulaLexer.CALL)
{
throw new MethodNotFoundException(
string.Format("Method with name '{0}' does not exist.", methodName));
}
return(null);
}
return(member.CreateExpression(callOn, parameters));
}
