Example #1
0
        public static async Task <CoverEditorViewModel> FromAsync(CoverManager manager, ICoverParent coverParent)
        {
            var viewModel = new CoverEditorViewModel
            {
                coverId = coverParent.CoverId
            };

            if (viewModel.coverId == null) // since cover id equal id, new object may contain null cover id.
            {
                throw new ArgumentNullException();
            }
            else
            {
                var cover = await manager.FindAsync(viewModel.coverId);

                if (cover == null)
                {
                    viewModel.CreateMode();
                }
                else
                {
                    viewModel.ModifyMode(cover);
                }
            }
            return(viewModel);
        }
Example #2
0
	protected override void Awake()
	{
		base.Awake();

		lastKnownPosition = Dependency.Get<LastKnownPosition>();
		coverManager = Dependency.Get<CoverManager>();
	}
 public CombineAction(VideoRoleManager manager, CoverManager coverManager, string sourceId, string destId)
 {
     this.manager      = manager;
     this.coverManager = coverManager;
     this.sourceId     = sourceId;
     this.destId       = destId;
 }
Example #4
0
    private bool TryFindCoverPoint(Vector3 playerToEnemyNormalised, out CoverPoint coverFound)
    {
        coverFound = null;
        var success = false;

        var coverPoints = CoverManager.GetCoverPointsSortedByDistanceTo(transform.position);

        if (coverPoints != null)
        {
            var playerPosition = GameManager.PlayerPosition;
            var myPosition     = CachedTransform.position;

            for (int i = 0; !success && (i < coverPoints.Count); ++i)
            {
                L(coverPoints[i].name);
                if (IsSuitableCover(playerPosition, coverPoints[i], myPosition, playerToEnemyNormalised))
                {
                    success    = true;
                    coverFound = coverPoints[i];
                }
                L("------------------");
            }
        }

        return(success);
    }
Example #5
0
    private void Awake()
    {
        Instance = this;

        _coversSorted = new List <CoverPoint>(capacity: coverPoints.Length);
        _coversSorted.AddRange(coverPoints);
    }
 public CoverCaption(CoverManager coverManager, string font_name, Color color)
     : base(coverManager, font_name, color)
 {
     CoverManager.NewCurrentCover += HandleNewCurrentCover;
     CoverManager.TargetIndexChanged += HandleTargetIndexChanged;
     CoverManager.CoversChanged += HandleCoversChanged;
 }
 protected void OnModelReloadedHandler(object o, EventArgs args)
 {
     if (model_count != album_loader.Model.Count)
     {
         model_count = album_loader.Model.Count;
         CoverManager.ReloadCovers();
     }
 }
 public ArtworkLookup(CoverManager cover_manager)
 {
     //Log.Debug ("ArtworkLookup ctor ()");
     this.cover_manager = cover_manager;
     this.cover_manager.TargetIndexChanged += HandleTargetIndexChanged;
     artwork_manager = ServiceManager.Get <ArtworkManager> ();
     artwork_manager.AddCachedSize(cover_manager.TextureSize);
 }
Example #9
0
        protected override void OnLateInitialize()
        {
            Body   = this.GetComponent <LSBody> ();
            inited = true;
            Generate();

            CoverManager.Assimilate(this);
        }
Example #10
0
    protected override void mapBindings()
    {
        base.mapBindings();

        GameObject managers  = GameObject.Find("Managers");
        GameObject resources = GameObject.Find("Resources");
        GameObject ui        = GameObject.Find("UI");

        injectionBinder.Bind <IRootContext>().ToValue(this).ToSingleton();

        EventManager eventManager = managers.GetComponent <EventManager>();

        injectionBinder.Bind <IEventManager>().ToValue(eventManager).ToSingleton();

        GameManager gameManager = managers.GetComponent <GameManager>();

        injectionBinder.Bind <IGameManager>().ToValue(gameManager).ToSingleton();

        BoardManager boardManager = managers.GetComponent <BoardManager>();

        injectionBinder.Bind <IBoardManager>().ToValue(boardManager).ToSingleton();

        UnitMaterialManager unitMaterialManager = resources.GetComponent <UnitMaterialManager>();

        injectionBinder.Bind <IUnitMaterialManager>().ToValue(unitMaterialManager).ToSingleton();

        UnitImageManager unitImageManager = resources.GetComponent <UnitImageManager>();

        injectionBinder.Bind <IUnitImageManager>().ToValue(unitImageManager).ToSingleton();

        UnitManager unitManager = managers.GetComponent <UnitManager>();

        injectionBinder.Bind <IUnitManager>().ToValue(unitManager).ToSingleton();

        SelectionManager selectionManager = managers.GetComponent <SelectionManager>();

        injectionBinder.Bind <ISelectionManager>().ToValue(selectionManager).ToSingleton();

        CoverManager coverManager = managers.GetComponent <CoverManager>();

        injectionBinder.Bind <ICoverManager>().ToValue(coverManager).ToSingleton();

        IWinManager winManager = managers.GetComponent <WinManager>();

        injectionBinder.Bind <IWinManager>().ToValue(winManager).ToSingleton();

        UnitMenuManager unitMenuManager = ui.GetComponent <UnitMenuManager>();

        Inject(unitMenuManager);

        UnitTutorialMenu unitTutorialMenu = ui.GetComponent <UnitTutorialMenu>();

        Inject(unitTutorialMenu);

        ContinueScript continueScript = ui.GetComponent <ContinueScript>();

        Inject(continueScript);
    }
Example #11
0
 public ClutterFlowAlbum(AlbumInfo album, CoverManager coverManager) : base(coverManager)
 {
     this.album = album;
     if (artwork_lookup == null)
     {
         artwork_lookup = new ArtworkLookup(CoverManager);
     }
     artwork_lookup.Enqueue(this);
 }
    // Use this for initialization
    void Start()
    {
        int squad_size = 0;

        level_generator   = gameObject.GetComponent <LevelGenerator>();
        squad_generator   = gameObject.GetComponent <SquadGenerator>();
        enemy_generator   = gameObject.GetComponent <EnemyGenerator>();
        cover_manager     = gameObject.GetComponent <CoverManager>();
        formation_manager = gameObject.GetComponent <FormationManager>();

        squadies = new List <GameObject>();
        enemies  = new List <GameObject>();

        // Generate Squad
        if (no_of_squadies > 8)
        {
            no_of_squadies = 8;
        }

        //no_of_enemies = no_of_squadies * 2;

        level_generator.GenerateNewLevel(level_height, level_width, grid_section_size);

        Vector3 level_size = new Vector3(level_width * grid_section_size, 0.0f, level_height * grid_section_size);

        // This is to stop duplicate cover spots spawning!
        if (cover_spacing <= 0)
        {
            cover_spacing = 1;
        }

        cover_manager.GenerateCoverPoints(level_size, no_cover_passes_across, no_cover_passes_up, cover_spacing);

        // Set Player position
        player.transform.position = new Vector3(player.transform.position.x, 1.0f, player.transform.position.z);

        // Position ID's
        cover_manager.SetSquads(no_of_squadies);

        squad_generator.GenerateSquad(no_of_squadies, cover_manager.StartupCover(no_of_squadies, player.transform.position), ref squadies);

        if (no_of_squadies % 2 == 1)             // If we have a remainder ie Squad sizes are not even
        {
            squad_size = no_of_squadies / 2 + 1; // We use the biggest squad size
        }

        if (no_of_squadies % 2 == 0) // If they are even all good
        {
            squad_size = no_of_squadies / 2;
        }

        // Tell the formation manager about the largest squad size
        formation_manager.GenerateFormations(player, squad_size);

        //enemy_generator.GenerateEnemies(no_of_enemies, cover_manager.GetEnemyPositions(no_of_enemies, enemy_generator.GetSpawnPoints()), ref enemies);
    }
Example #13
0
    // Start is called before the first frame update
    void Start()
    {
        myTransform = transform;
        myTeam      = GetComponent <Team>();
        myVitals    = GetComponent <Vitals>();
        anim        = GetComponent <Animator>();

        coverManager           = GameObject.FindObjectOfType <CoverManager>();
        curCoverChangeCooldown = coverChangeCooldown;
    }
        public override void Dispose()
        {
            if (disposed)
            {
                return;
            }
            disposed = true;

            DetachEvents();
            AlbumLoader.Dispose();
            CoverManager.Dispose();
        }
Example #15
0
    public Command GenerateTransitionCommand()
    {
        Cover cover = CoverManager.FindCover(CachedTurn.GetBodiesInLine(FixedMath.One * 200), CurrentCover);

        if (cover != null)
        {
            Command com = new Command(this.Data.ListenInputID, this.Agent.Controller.ControllerID);
            com.Add <DefaultData> (new DefaultData(DataType.UShort, cover.ID));
            return(com);
        }
        return(null);
    }
Example #16
0
 private void HandleWin()
 {
     TransitionPanel.SetActive(true);
     if (WinManager.PlayerWon.Equals(PlayerInfo.UNKNOWN))
     {
         TransitionText.text = "DRAW";
     }
     else
     {
         TransitionText.text = WinManager.PlayerWon.Name + System.Environment.NewLine + "won!";
     }
     CoverManager.ClearMask();
 }
        public Caption(CoverManager coverManager, string font_name, Color color) : base(clutter_text_new())
        {
            this.coverManager = coverManager;
            Editable          = false;
            Selectable        = false;
            Activatable       = false;
            CursorVisible     = false;
            LineAlignment     = Pango.Alignment.Center;
            FontName          = font_name;
            Color             = color;
            TextProp          = DefaultValue;

            UpdatePosition();
        }
        public ClutterFlowSlider(float width, float height, CoverManager coverManager)
        {
            this.Reactive                     = true;
            this.coverManager                 = coverManager;
            CoverManager.CoversChanged       += HandleCoversChanged;
            CoverManager.TargetIndexChanged  += HandleTargetIndexChanged;
            CoverManager.LetterLookupChanged += HandleLetterLookupChanged;

            this.SetSize(width, height);
            this.Entered    += HandleEnterEvent;
            this.LeaveEvent += HandleLeaveEvent;

            InitChildren();
            Update();
        }
        public ClutterFlowView() : base()
        {
            SetSizeRequest(300, 200);
            Clutter.Global.MotionEventsEnabled = true;

            album_loader  = new AlbumLoader();
            cover_manager = new CoverManager(album_loader, GetDefaultSurface, ClutterFlowSchemas.TextureSize.Get());

            AttachEvents();

            SetupViewport();
            SetupSlider();
            SetupLabels();
            SetupWidgetBar();
        }
        public Caption(CoverManager coverManager, string font_name, Color color)
            : base(clutter_text_new ())
        {
            this.coverManager = coverManager;
            Editable = false;
            Selectable = false;
            Activatable = false;
            CursorVisible = false;
            LineAlignment = Pango.Alignment.Center;
            FontName = font_name;
            Color = color;
            TextProp = DefaultValue;

            UpdatePosition ();
        }
Example #21
0
 protected override void OnExecute(Command com)
 {
     if (com.ContainsData <DefaultData>())
     {
         DefaultData data = com.GetData <DefaultData> ();
         if (data.DataType == DataType.UShort)
         {
             Cover cover = CoverManager.GetCover((ushort)data.Value);
             this.StartTransition(cover);
         }
         else if (data.DataType == DataType.Long)
         {
             Input = (long)data.Value;
         }
     }
 }
Example #22
0
            /// <summary>
            /// return true if success.
            /// </summary>
            /// <param name="dataCenter"></param>
            /// <param name="source"></param>
            /// <returns></returns>
            public async Task <bool> GenerateAsync(DataCenter dataCenter, ICoverParent source)
            {
                var client = JryVideoCore.Current.GetTheTVDBClient();

                if (client == null)
                {
                    return(false);
                }

                this.coverManager = dataCenter.CoverManager;
                return(await this.AutoGenerateCoverAsync(client, this.source.InfoView.Source) ||
                       await this.AutoGenerateCoverOverTheTVDBIdAsync(client,
                                                                      this.source.InfoView.SeriesView.Source.TheTVDBId,
                                                                      this.source.InfoView.Source.Index.ToString()) ||
                       await this.AutoGenerateCoverAsync(client, this.source.InfoView.SeriesView.Source));
            }
Example #23
0
    private void Start()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);

            GameObject[] objs = GameObject.FindGameObjectsWithTag("Cover");

            foreach (GameObject o in objs)
            {
                Covers.Add(o.GetComponent <Cover>());
            }
            coversToUpdate = Covers;
        }
        else
        {
            Destroy(gameObject);
        }
    }
        public List <ClutterFlowBaseActor> GetActors(CoverManager cover_manager)
        {
            SortedList <AlbumInfo, ClutterFlowBaseActor> list =
                new SortedList <AlbumInfo, ClutterFlowBaseActor>(Comparer);

            if (Model != null)
            {
                for (int i = 1; i < Model.Count; i++)
                {
                    AddActorToList(Model[i], list, cover_manager);
                }
                index_map = new List <int>(list.Values.Count);
                for (int i = 0; i < list.Values.Count; i++)
                {
                    ClutterFlowBaseActor actor = list.Values[i];
                    index_map.Add(actor.Index);
                    actor.Index = i;
                }
            }
            return(new List <ClutterFlowBaseActor>(list.Values));
        }
        public void SetModel(FilterListModel <AlbumInfo> value)
        {
            if (value != album_loader.Model)
            {
                if (album_loader.Model != null)
                {
                    album_loader.Model.Cleared  -= OnModelClearedHandler;
                    album_loader.Model.Reloaded -= OnModelReloadedHandler;
                }

                album_loader.Model = value;

                if (album_loader.Model != null)
                {
                    album_loader.Model.Cleared  += OnModelClearedHandler;
                    album_loader.Model.Reloaded += OnModelReloadedHandler;
                    model_count = album_loader.Model.Count;
                }
                CoverManager.ReloadCovers();
            }
        }
 protected void OnModelClearedHandler(object o, EventArgs args)
 {
     CoverManager.ReloadCovers();
 }
 public CoverCaption(CoverManager coverManager, string font_name, Color color) : base(coverManager, font_name, color)
 {
     CoverManager.NewCurrentCover    += HandleNewCurrentCover;
     CoverManager.TargetIndexChanged += HandleTargetIndexChanged;
     CoverManager.CoversChanged      += HandleCoversChanged;
 }
 public TrackCaption(CoverManager coverManager, string font_name, Color color)
     : base(coverManager, font_name, color)
 {
 }
Example #29
0
 public TrackCaption(CoverManager coverManager, string font_name, Color color) : base(coverManager, font_name, color)
 {
 }
Example #30
0
            /// <summary>
            /// return true if success.
            /// </summary>
            /// <param name="dataCenter"></param>
            /// <param name="source"></param>
            /// <returns></returns>
            public async Task<bool> GenerateAsync(DataCenter dataCenter, ICoverParent source)
            {
                var client = JryVideoCore.Current.GetTheTVDBClient();
                if (client == null) return false;

                this.coverManager = dataCenter.CoverManager;
                return await this.AutoGenerateCoverAsync(client, this.source.InfoView.Source) ||
                       await this.AutoGenerateCoverOverTheTVDBIdAsync(client,
                           this.source.InfoView.SeriesView.Source.TheTVDBId,
                           this.source.InfoView.Source.Index.ToString()) ||
                       await this.AutoGenerateCoverAsync(client, this.source.InfoView.SeriesView.Source);
            }
Example #31
0
 private void OnDestroy()
 {
     Instance = null;
 }
Example #32
0
 public AutoGenerateCoverProvider(CoverManager manager)
 {
     this.manager = manager;
 }
 public CombineAction(VideoRoleManager manager, CoverManager coverManager, string sourceId, string destId)
 {
     this.manager = manager;
     this.coverManager = coverManager;
     this.sourceId = sourceId;
     this.destId = destId;
 }
Example #34
0
 protected override void OnSimulate()
 {
     CoverManager.Simulate();
 }
Example #35
0
 protected override void OnInitialize()
 {
     CoverManager.Initialize();
 }
Example #36
0
 protected override void OnDeactivate()
 {
     CoverManager.Deactivate();
 }