public void Start () {
_spriteRenderer = GetComponent<SpriteRenderer>();
_originalColor = _spriteRenderer.color;
_enemyModel = new ActorModel(transform.position, InitialHealth);
_enemyModel.RegisterListener(this);
_aiController = new EnemyAiController(_enemyModel, 1f, 3f, soundManager);
}
void Awake()
{
mActorModel = gameObject.GetComponent("ActorModel") as ActorModel;
if (mActorModel == null)
{
throw new MissingComponentException("Unable to find actor model on gameObject.");
}
}
public void Awake()
{
mActorModel = GetComponent("ActorModel") as ActorModel;
if (mActorModel == null)
{
throw new MissingComponentException("Unable to find ActorModel.");
}
}
public IActorState Update(ActorModel actorModel, float deltaTime) {
_timeElapsed += deltaTime;
if (_timeElapsed < StunDuration) {
return this;
} else {
actorModel.AnimationState = ActorAnimationState.Walking;
return new ActorWalkState();
}
}
public EnemyAiController(ActorModel actorModel, float attackRange, float velocity, Sound soundManager) {
this._actorModel = actorModel;
_attackRange = attackRange;
_velocity = velocity;
this.soundManager = soundManager;
PickAiType();
ResetDecisionTimer();
}
public IActorState GetHurt(ActorModel actorModel) {
actorModel.Position -= actorModel.LookDirection * 3f;
actorModel.Health -= 25f;
if (actorModel.Health > 5) {
actorModel.AnimationState = ActorAnimationState.GettingHurt;
return new ActorStunState(0.2f);
} else {
actorModel.AnimationState = ActorAnimationState.Death;
return GetHurtBadly(actorModel);
}
}
// GET: Edit
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ActorModel Actor = _ActorRep.GetActorById(id);
if (Actor == null)
{
return(HttpNotFound());
}
return(View(Actor));
}
public StreamProvider(string name, bool isRewindable)
{
this.name = name;
this.isRewindable = isRewindable;
if (StreamDictionaryMachineID == null)
{
StreamDictionaryMachineID = ActorModel.Runtime.CreateMachine(typeof(StreamDictionaryMachine));
}
ActorModel.RegisterCleanUpAction(() =>
{
StreamDictionaryMachineID = null;
});
}
// GET: ActorModels/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ActorModel actorModel = db.ActorModels.Find(id);
if (actorModel == null)
{
return(HttpNotFound());
}
return(View(actorModel));
}
protected ActorModel GetModel(int index, ExteriorArithmeticUnit exteriorUnit)
{
ActorModel actorModel = ModelPool.Instance.Get(exteriorUnit.FinalModelID);
actorModel.ModelType = ActorModelType.UI;
actorModel.ModelLayer = "NPC";
actorModel.set_name(index.ToString());
actorModel.get_transform().set_position(new Vector3((float)(-1000 * (index + 1)), 1000f, 0f));
actorModel.EquipOn(exteriorUnit.FinalWeaponID, exteriorUnit.FinalWeaponGogok);
actorModel.EquipOn(exteriorUnit.FinalClothesID, 0);
actorModel.EquipWingOn(exteriorUnit.FinalWingID);
LayerSystem.SetGameObjectLayer(actorModel.get_gameObject(), "NPC", 1);
actorModel.PreciseSetAction("idle_city");
return(actorModel);
}
public ActorController(
ActorSettings settings,
ActorModel model,
MoveHandler moveHandler,
InteractHandler interactHandler,
PushHandler pushHandler,
ResetHandler resetHandler)
{
_settings = settings;
_model = model;
_moveHandler = moveHandler;
_interactHandler = interactHandler;
_pushHandler = pushHandler;
_resetHandler = resetHandler;
}
/// <summary>
/// Constructor. Grain implementers do not have to expose this
/// constructor but can choose to do so. This constructor is
/// particularly useful for unit testing where test code can
/// create a Grain and replace the IGrainIdentity and IGrainRuntime
/// with test doubles.
/// </summary>
/// <param name="identity">IGrainIdentity</param>
/// <param name="runtime">IGrainRuntime</param>
protected Grain(IGrainIdentity identity, IGrainRuntime runtime)
{
this.Identity = identity;
this.Runtime = runtime;
if (StreamProviderDictionaryMachineId == null)
{
StreamProviderDictionaryMachineId = ActorModel.Runtime.CreateMachine(
typeof(StreamProviderDictionaryMachine), "StreamProviderDictionaryMachine");
}
ActorModel.RegisterCleanUpAction(() =>
{
StreamProviderDictionaryMachineId = null;
});
}
static void Main(string[] args)
{
var obj = ActorProxy.Create <IHuman>(new ActorId(2), "ABC");
Task <int> t = obj.Eat(9, 2, "qwer");
int x = ActorModel.GetResult <int>(t);
Console.WriteLine(x);
//var obj = new HumanProxy(PSharpRuntime.Create());
//Task<int> t = obj.Eat(10, 97, "asdf");
//int x = ActorModel.GetResult<int>(t);
//Console.WriteLine(x);
Console.ReadLine();
}
public IActionResult ChooseRace()
{
if (HasCharacter())
{
return(RedirectToAction("EditStats"));
}
var actor = new ActorModel()
{
Name = Context.User.Identity.Name
};
ViewBag.Races = KatanaMUD.Game.Data.RaceTemplates.ToList();
return(View(actor));
}
public string AddTrack(TrackCreateCommand createTrack)
{
WithValidation(() => CommandValidator.Validate(createTrack));
var trackId = Guid.NewGuid().ToString();
var trackCreated = new TrackCreated
{
Binary = createTrack.Binary,
OwnerId = createTrack.OwnerId,
Timestamp = createTrack.Timestamp,
TrackId = trackId,
};
ActorModel.Tell(ActorModel.TrackPapaPath, trackCreated);
return(trackId);
}
public async Task AccessSafe()
{
bool isSafeOpen = await this.StateManager.GetStateAsync <bool>("IsSafeOpen");
if (isSafeOpen)
{
ActorModel.Log("[LOG] The safe is closed.");
await this.StateManager.SetStateAsync("IsSafeOpen", false);
}
else
{
ActorModel.Log("[LOG] The safe is open.");
await this.StateManager.SetStateAsync("IsSafeOpen", true);
}
}
//IGrainReminder myReminder;
//public override async Task OnActivateAsync()
//{
//var reminderTask = this.RegisterOrUpdateReminder("helloReminder", TimeSpan.FromSeconds(2),
// TimeSpan.FromSeconds(0));
//ActorModel.Wait(reminderTask);
//myReminder = ActorModel.GetResult<IGrainReminder>(reminderTask);
////this.Timer = this.RegisterTimer(HandleTimeout, null,
//// TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(0));
// await base.OnActivateAsync();
//}
public async Task DoSomething(int numberOfItems)
{
var receiver = GrainClient.GrainFactory.GetGrain <IReceiver>(1);
await receiver.StartTransaction();
for (int i = 0; i < numberOfItems; i++)
{
await receiver.TransmitData(new TransactionItems("xyz" + i));
}
int transmitted = await receiver.GetCurrentCount();
ActorModel.Assert(transmitted <= numberOfItems, "Items sent: " + numberOfItems + "; Transmitted: " + transmitted);
}
public Task ProcessResponse()
{
ActorModel.Log($"<RaftLog> Client received a response.");
if (this.RequestTimer != null)
{
this.RequestTimer.Dispose();
this.RequestTimer = null;
}
this.RequestTimer = this.RegisterTimer(PumpRequest, null,
TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(5));
return(TaskDone.Done);
}
/// <summary>
/// Initializes a new instance of the <see cref="CommentViewModel"/> class.
/// </summary>
/// <param name="thread">The thread that the comment is a part of.</param>
/// <param name="currentUser">The current user.</param>
/// <param name="model">The comment model.</param>
protected CommentViewModel(
ICommentThreadViewModel thread,
ActorModel currentUser,
CommentModel model)
: this(
thread,
new ActorViewModel(currentUser),
model.Id,
model.Body,
CommentEditState.None,
new ActorViewModel(model.Author),
model.CreatedAt,
new Uri(model.Url))
{
}
public override void TakeMsg(ActorModel who, EventMsg msg)
{
switch (msg.Type)
{
case EventType.GetBumped:
God.C.AddAction(new BumpAction(msg.Source, who.Location.x, who.Location.y));
msg.Source.TakeMsg(new EventMsg(EventType.TakeDmg, who, God.Library.GetMonster(who.Species).Damage));
who.Despawn();
return;
case EventType.GetName:
msg.Text += " " + God.Library.GetMonster(who.Species).Type;
return;
}
}
public Task RelayClientRequest(int clientId, int command)
{
ActorModel.Log($"<RaftLog> ClusterManager is relaying client request " + command + "\n");
if (this.Leader != null)
{
this.Leader.ProcessClientRequest(clientId, command);
}
else
{
this.Cluster.RedirectClientRequest(clientId, command);
}
return(TaskDone.Done);
}
public Task <Location> GotoRoom()
{
if (ActorModel.Random())
{
return(Task.FromResult(Location.Garden));
}
else if (ActorModel.Random())
{
return(Task.FromResult(Location.Kitchen));
}
else
{
return(Task.FromResult(Location.Bedroom));
}
}
private new void Awake()
{
base.Awake();
#if UNITY_EDITOR
if (ActorModel.Model == null)
{
ActorModel.CreateModel();
}
GameStaticMethod.GameInit();
#endif
enemySpawners = GetComponentsInChildren <EnemySpawn>();
SpawnEnemys();
GetView <GameInfoView>().SetTipText("第" + level + "层");
}
public void InsertOrUpdate(ActorModel actor)
{
var actorEntity = _mapper.Map <Actor>(actor);
if (actorEntity.Id == Guid.Empty)
{
actorEntity.Id = Guid.NewGuid();
actorEntity.CreatedAt = DateTime.Now;
_uow.Get <Actor>().Add(actorEntity);
}
else
{
actorEntity.LastModifiedAt = DateTime.Now;
_uow.Get <Actor>().Update(actorEntity);
}
}
/// <summary>
/// 新增明細
/// </summary>
/// <param name="detail"></param>
/// <returns></returns>
public bool AddDetail(DetailViewModel detail)
{
#region 參數宣告
bool result = false;
ActorModel actor = new ActorModel();
IActorRepository actorRp = new ActorRepository();
#endregion
#region 流程
actor = PropertyCopy.Convert <DetailViewModel, ActorModel>(detail);
result = actorRp.AddActor(actor);
return(result);
#endregion
}
public static ActorModel GetModel(int wingModelId)
{
ActorModel actorModel = ModelPool.Instance.Get(EntityWorld.Instance.EntSelf.ModelID);
actorModel.ModelType = ActorModelType.UI;
actorModel.ModelLayer = "NPC";
float num = (float)(-1000 * (WingGlobal.models.get_Count() + 1));
actorModel.get_transform().set_position(new Vector3(num, 0f));
actorModel.EquipOn(EntityWorld.Instance.EntSelf.EquipCustomizationer.GetIdOfWeapon(), 0);
actorModel.EquipOn(EntityWorld.Instance.EntSelf.EquipCustomizationer.GetIdOfClothes(), 0);
actorModel.EquipWingOn(wingModelId);
LayerSystem.SetGameObjectLayer(actorModel.get_gameObject(), "NPC", 1);
actorModel.ShowSelf(true);
return(actorModel);
}
private Task PumpRequest(object args)
{
if (this.RequestTimer != null)
{
this.RequestTimer.Dispose();
this.RequestTimer = null;
}
this.LatestCommand = new Random().Next(100);
ActorModel.Log($"<RaftLog> Client is sending new request {this.LatestCommand}.");
this.ClusterManager.RelayClientRequest(6, this.LatestCommand);
return(TaskDone.Done);
}
public async Task CanBeExecutedForCommentsByTheSameAuthor()
{
var session = CreateSession();
var thread = CreateThread();
var currentUser = new ActorModel {
Login = "******"
};
var comment = new PullRequestReviewCommentModel {
Author = currentUser
};
var target = await CreateTarget(session, null, thread, currentUser, null, comment);
Assert.That(target.BeginEdit.CanExecute(new object()), Is.True);
}
//protected override Task OnActivateAsync()
//{
// (this as IActor1).Foo();
// return base.OnActivateAsync();
//}
public Task Foo()
{
var actor2Proxy = ActorProxy.Create <IActor2>(new ActorId(1), "A2");
int val = 9;
var t = actor2Proxy.SetValue(val, this);
Console.WriteLine("Actor1 is waiting for set value from Actor2");
//ActorModel.Wait(t);
Task <int> s = actor2Proxy.GetValue();
var r = ActorModel.GetResult <int>(s);
Console.WriteLine(r);
return(Task.FromResult(true));
}
public Entity GetWorld()
{
if (world == null)
{
ActorModel worldActor = new ActorModel();
worldActor.uid = -999;
worldActor.id = -999;
GameObject worldGo = new GameObject("<------------EntityWorld---------->");
ActorObj actorObj = worldGo.AddComponent <ActorObj>();
actorObj.Init(worldActor, -999);
world = GetEntity(-999);
}
return(world);
}
public static ActorModel ToModel(this Actor entity)
{
if (entity == null)
{
return(null);
}
var model = new ActorModel
{
Id = entity.Id,
Name = entity.Name,
Imdb = entity.Imdb,
};
return(model);
}
private Task RedirectClientRequest(object args)
{
var request = (Tuple <int, int>)args;
if (this.RetryTimer != null)
{
this.RetryTimer.Dispose();
this.RetryTimer = null;
}
ActorModel.Log($"<RaftLog> ClusterManager is redirecting client request " + request.Item2 + "\n");
this.Cluster.RelayClientRequest(request.Item1, request.Item2);
return(TaskDone.Done);
}
public IHttpActionResult AddNewActor(ActorModel actor)
{
try
{
if (actor == null || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
actorService.AddNewActor(actor);
}
catch (Exception ex)
{
return(InternalServerError());
}
return(new MyMessageResult("New Actor Successfully", Request));
}
public StatsPanel(ContentManager content, ActorModel player, Vector2 position)
{
_font = content.Load <SpriteFont>("Fonts/ButtonFont");
_player = player;
_position = position;
var displayPictureTexture = content.Load <Texture2D>("AfterBattle/DisplayPicture");
_displayPicture = new Sprite(displayPictureTexture)
{
Position = position + new Vector2((displayPictureTexture.Width / 2) - 10, (displayPictureTexture.Height / 2) + 30),
Opacity = 0f,
};
}
public static void Execute(PSharpRuntime runtime)
{
//Configuration conf = Configuration.Create(true, true, true, true, true);
//ActorModel.Configure(conf);
ActorModel.Start(runtime, () =>
{
var config = ClientConfiguration.LocalhostSilo();
GrainClient.Initialize(config);
runtime.RegisterMonitor(typeof(SafetyMonitor));
var clusterManager = GrainClient.GrainFactory.GetGrain <IClusterManager>(0);
clusterManager.Configure();
});
}
/// <summary>
/// Static constructor.
/// </summary>
static GrainClient()
{
GrainClient.GrainFactory = new GrainFactory();
GrainClient.Runtime = new GrainRuntime(GrainClient.GrainFactory);
string assemblyPath = Path.GetDirectoryName(Assembly.GetCallingAssembly().Location);
ProxyFactory = ActorModel.Runtime.CreateMachine(typeof(OrleansGrainFactory),
new ActorFactory.InitEvent(assemblyPath));
ActorModel.RegisterCleanUpAction(() =>
{
ProxyFactory = ActorModel.Runtime.CreateMachine(typeof(OrleansGrainFactory),
new ActorFactory.InitEvent(assemblyPath));
});
}
public abstract IActorState LookTowards(ActorModel actorModel, Vector2 direction);
public override IActorState Jump(ActorModel actorModel) {
return this;
}
public abstract IActorState Move(ActorModel actorModel, Vector2 position);
public override IActorState Jump(ActorModel actorModel) {
throw new System.NotImplementedException();
}
public abstract IActorState Update(ActorModel actorModel, float deltaTime);
public override IActorState Attack(ActorModel actorModel) {
actorModel.AnimationState = ActorAnimationState.Attacking;
return new ActorAttackState();
}
public override IActorState Update(ActorModel actorModel, float deltaTime) {
return this;
}
public override IActorState Move(ActorModel actorModel, Vector2 position) {
actorModel.Position += position;
return this;
}
public abstract IActorState Attack(ActorModel actorModel);
public virtual void Start() {
ActorModel = new ActorModel(transform.position, 100f);
ActorModel.RegisterListener(this);
}
public abstract IActorState Jump(ActorModel actorModel);
public IActorState Attack(ActorModel actorModel) {
return this;
}
public IActorState LookTowards(ActorModel actorModel, Vector2 direction) {
return this;
}
public IActorState GetHurtBadly(ActorModel actorModel) {
return this;
}
public override IActorState LookTowards(ActorModel actorModel, Vector2 direction) {
actorModel.LookDirection = direction;
return this;
}
public IActorState Move(ActorModel actorModel, Vector2 position) {
return this;
}
public override IActorState Attack(ActorModel actorModel) {
return this;
}
public IActorState Jump(ActorModel actorModel) {
return this;
}
