public ActorListViewModel(IMediator mediator,
IWarningService warningService,
ActorFacade facade)
{
usedMediator = mediator;
usedWarningService = warningService;
usedFacade = facade;
mediator.Register <YES_WarningResultMessage <ActorWrappedModel> >(DeleteActor);
mediator.Register <NO_WarningResultMessage <ActorWrappedModel> >(UpdateActors);
mediator.Register <UpdateMessage <ActorWrappedModel> >(UpdateActors);
ActorSelectedCommand = new RelayCommand <ActorListModel>(SendActorSelectedMessage);
AddButtonCommand = new RelayCommand(SendActorNewMessage);
DeleteButtonCommand = new RelayCommand(ExecuteWarning, IsEnabled_DeleteDetailButton);
DetailButtonCommand = new RelayCommand(SendDetailButtonPushedMessage, IsEnabled_DeleteDetailButton);
RefreshButtonCommand = new RelayCommand(Refresh);
SearchButtonCommand = new RelayCommand(StartSearching);
SearchedObject = defaultSearchingBoxMessage;
SearchingOptions = new List <string>()
{
"First name", "Second name"
};
SelectedOption = SearchingOptions[1];
Load();
}
public ActivePlayableState(ActorFacade actor)
{
this.actor = actor;
this.combatActionsMapping = DependencyLocator.GetActionsMapper <CombatActionsMapping>();
this.skillQueueResolver = DependencyLocator.GetSkillQueueResolver();
this.tilemapManager = DependencyLocator.getTilemapManager();
}
public ActorFacadeTest()
{
var dbContextFactory = new DbContextInMemoryFactory(nameof(ActorFacadeTest));
var unitOfWork = new UnitOfWork(dbContextFactory);
repository = new Repository <ActorEntity>(unitOfWork);
mapper = new ActorMapper();
facadeTestUnit = new ActorFacade(unitOfWork, repository, mapper);
}
public MoveAlongPathProcess(ActorFacade actor, IEnumerable <TileFacade> path, IFilter filter = null, float moveSpeed = 2.0f, float treshold = 0.05f)
{
this.moveSpeed = moveSpeed;
this.treshold = treshold;
this.actor = actor;
this.actorTransform = actor.transform;
this.path = new Queue <TileFacade>(path);
this.filter = filter;
}
public SelectActorViewModel(IMediator mediator,
ActorFacade facade)
{
usedMediator = mediator;
usedFacade = facade;
usedMediator.Register <DeleteMessage <ActorWrappedModel> >(ReloadList);
usedMediator.Register <UpdateMessage <ActorWrappedModel> >(ReloadList);
ItemSelectedCommand = new RelayCommand <ActorListModel>(ItemSelected);
LoadList();
}
public ActorDetailViewModel(IMediator mediator,
ActorFacade actorFacade,
IFileBrowserService fileBrowserSerice,
IOpenWebPageService openWebPageService)
{
usedMediator = mediator;
usedActorFacade = actorFacade;
usedFileBrowserService = fileBrowserSerice;
usedOpenWebPageService = openWebPageService;
usedMediator.Register <NewMessage <ActorWrappedModel> >(CreateNewWrappedModel);
usedMediator.Register <SelectedMessage <ActorWrappedModel> >(PrepareActor);
usedMediator.Register <MoveToDetailMessage <ActorWrappedModel> >(ShowDetailInfo);
FilmSelectedCommand = new RelayCommand <FilmActorWrappedModel>(MoveToFilmDetail);
EditButtonCommand = new RelayCommand(EnableEditing);
SaveButtonCommand = new RelayCommand(Save, CanSave);
UpdatePhotoButtonCommand = new RelayCommand(UpdatePhoto, UpdatePhotoEnabled);
OpenWikiButtonCommand = new RelayCommand(OpenWiki, OpenWikiEnabled);
}
public void In()
{
if (this.levelData == null)
{
return;
}
List <ActorFacade> newActors = new List <ActorFacade>();
foreach (ActorFacade actor in this.levelData.actors)
{
ActorFacade newActor = this.spawner.Spawn(actor);
newActors.Add(newActor);
}
this.spawner.Spawn(levelData.map);
this.tilemapManager.Init(new List <ITilemapAgent>(newActors));
this.timelineController.Init(new List <ITimelineAgent>(newActors));
this.combatActionsMapping.Enable();
}
private void ResolveSkill(Vector3 pos)
{
if (this.actor.Skills.Selected == null)
{
return;
}
TileFacade targetTile = this.tilemapManager.GetTileFromWorldPos(pos);
if (targetTile == null)
{
return;
}
ActorFacade caster = this.actor;
ActorFacade targetActor = (ActorFacade)targetTile.Agent;
SkillInput input = new SkillInput(caster, targetTile, targetActor);
this.skillQueueResolver.AddSkill(input, this.actor.Skills.Selected);
this.CancelSkill();
}
public HomeViewModel(IMediator mediator,
FilmFacade filmFacade,
ActorFacade actorFacade,
DirectorFacade directorFacade)
{
usedMediator = mediator;
usedFilmFacade = filmFacade;
usedActorFacade = actorFacade;
usedDirectorFacade = directorFacade;
SearchButtonCommand = new RelayCommand(StartSearching);
FoundItemSelected = new RelayCommand <FoundItem>(ShowDetail);
CloseListCommand = new RelayCommand(HideFoundItems);
SearchedObject = defaultSearchingBoxMessage;
SearchingOptions = new List <string>()
{
"All", "Films", "Actors", "Directors"
};
SelectedOption = SearchingOptions[0];
IsVisible = false;
}
public static void OnPlayableStateDisabled(ActorFacade actor)
{
eventQueue.Add(() => onPlayableStateDisabled?.Invoke(actor));
}
public SkillInput(ActorFacade caster, TileFacade targetTile, ActorFacade targetActor = null)
{
this.caster = caster;
this.targetTile = targetTile;
this.targetActor = targetActor;
}
private void DisableUI(ActorFacade actor)
{
this.RenderSkillButtons(actor.Skills.All, null, false);
}
private void EnableUI(ActorFacade actor, Action <Skill> selectSkill)
{
this.RenderSkillButtons(actor.Skills.All, selectSkill);
}
public ActorFacade Spawn(ActorFacade actor)
{
ActorFacade newActor = GameObject.Instantiate(actor);
return(newActor);
}
public void OnStatsChange(ActorFacade actor)
{
eventQueue.Add(() => this.onStatsChange?.Invoke(actor));
}
public static void OnPlayableStateEnabled(ActorFacade actor, Action <Skill> selectSkillAction)
{
eventQueue.Add(() => onPlayableStateEnabled?.Invoke(actor, selectSkillAction));
}
public MoveProcess(ActorFacade actor, TileFacade dest, ITopology topology, IFilter filter)
{
HashSet <TileFacade> path = DependencyLocator.getTileFinder().findPath(actor.GetTile(), dest, topology, filter);
this.moveAlongPathProcess = new MoveAlongPathProcess(actor, path, null, this.moveSpeed, this.treshold);
}