예제 #1
0
    void Start()
    {
        viewMesh            = new Mesh();
        viewMesh.name       = "view Mesh";
        viewMeshFilter.mesh = viewMesh;

        _targetObject = GameObject.Find("Player"); // GameObject.FindGameObjectsWithTag("player");
        _guardObject  = GameObject.Find("guard");
        _targetScript = _targetObject.GetComponent <MorphController>();
        _guardScript  = _guardObject.GetComponent <EnemyPatrol>();

        StartCoroutine("FindTargetsWithDelay", .2f);
    }
예제 #2
0
    void CreateStage()
    {
        Vector3 position = gameObject.transform.position - new Vector3(0, morphDistance, 0);

        Debug.Log(gameObject.transform.position);
        Debug.Log(position);
        MorphController newStage = Instantiate(GetStage(), position, Quaternion.identity);

        newStage.morphDuration = morphDuration;
        stages.CopyTo(newStage.stages, 0);
        newStage.numMorphs     = numMorphs + 1;
        newStage.morphDistance = morphDistance;
    }
예제 #3
0
        private void UICreateMorphRow(int i, string morphName, bool morphEnabled, string atomName, bool initialCreation)
        {
            if (morphName == null || morphName == String.Empty || morphName == NONE)
            {
                return;
            }

            if (atomName == null || atomName == String.Empty)
            {
                return;
            }


            DAZMorph morph = MorphController.GetMorphByDisplayName(morphName);

            if (morph == null)
            {
                SuperController.LogError($"Unable to find morph by name {morphName}", false);
                return;
            }

            Atom atom = SuperController.singleton.GetAtomByUid(atomName);

            if (atom == null)
            {
                SuperController.LogError($"Unable to find atom by name {atomName}", false);
                return;
            }

            bool onRightSide = (i % 2 == 1);

            // at this point we are guaranteeed to have a morph / atom object
            TrackedMorph trackedMorph;

            try {
                trackedMorph = new TrackedMorph(morph, atom, 0, morphEnabled);
            }
            catch (Exception e) {
                SuperController.LogMessage(e.ToString());
                throw;
            }

            if (initialCreation)
            {
                // move the atom to match the morph if we just added the morph
                trackedMorph.SyncFromMorph();
            }

            // invisible atom name (storage in json)
            var a = new JSONStorableString(TrackedMorphAtomNameKey(i), String.Empty);

            a.storeType = JSONStorableParam.StoreType.Full;
            RegisterString(a);
            a.val = trackedMorph.Atom.name;

            // invisible morph name (storage in json)
            var ms = new JSONStorableString(TrackedMorphNameKey(i), String.Empty);

            ms.storeType = JSONStorableParam.StoreType.Full;
            RegisterString(ms);
            ms.val = trackedMorph.Morph.displayName; // set to non-default to force json save

            // invisible morph enabled (storage in json)
            var me = new JSONStorableBool(TrackedMorphEnabledKey(i), !trackedMorph.Enabled);

            me.storeType = JSONStorableParam.StoreType.Full;
            RegisterBool(me);
            me.val = trackedMorph.Enabled;  // set to non-default to force json save

            // the visible checkbox (not tracked in json)
            var morphId = $"Record / Play {trackedMorph.Morph.displayName}";
            var m       = new JSONStorableBool(morphId, false, (bool value) =>
            {
                // update the hidden variable for tracking
                me.val = value;
                // update the tracked morph
                trackedMorph.Enabled = value;
            });

            m.storeType = JSONStorableParam.StoreType.Full;
            CreateToggle(m, onRightSide);
            m.val = trackedMorph.Enabled;

            TrackedMorphs.Add(trackedMorph);
            TrackingCountJSON.val += 1;
        }
예제 #4
0
        private void UICreateAddForm()
        {
            var groupNames = MorphController.GetMorphs().OrderBy(m => m.group.ToLowerInvariant()).Select(m => m.group).Distinct().ToList();

            NewMorphFilterJSON = new JSONStorableStringChooser(NewMorphFilterKey,
                                                               groupNames,
                                                               ALL,
                                                               "Filter Morphs",
                                                               (string filter) =>
            {
                NewMorphNameJSON.val     = String.Empty;
                NewMorphNameJSON.choices = UIMorphNames;
            });
            CreateFilterablePopup(NewMorphFilterJSON);

            // the exact morph to add
            NewMorphNameJSON = new JSONStorableStringChooser(NewMorphNameKey, UIMorphNames, String.Empty, "Morph");
            var p = CreateFilterablePopup(NewMorphNameJSON, rightSide: true);

            p.popupPanelHeight = 1100f;


            // left hand side arm for record
            var armButton = CreateButton("Arm selected morphs for record");

            armButton.button.onClick.AddListener(() => {
                foreach (var tracked in TrackedMorphs)
                {
                    var motionAnimationControl = tracked.Atom.GetComponentInChildren <MotionAnimationControl>();
                    if (motionAnimationControl == null)
                    {
                        continue;
                    }

                    if (!tracked.Enabled)
                    {
                        SuperController.LogMessage($"un-arming {tracked.Atom.name} for record");
                        motionAnimationControl.armedForRecord = false;
                    }
                    else
                    {
                        SuperController.LogMessage($"arming {tracked.Atom.name} for record");
                        motionAnimationControl.armedForRecord = true;
                    }
                }
            });

            // "add" button
            var b = CreateButton("Add morph...", rightSide: true);

            b.button.onClick.AddListener(() =>
            {
                int i         = (int)TrackingCountJSON.val;
                var morphName = NewMorphNameJSON.val ?? String.Empty;

                // only allow one morph with a name to be added at a time
                if (TrackedMorphs.FirstOrDefault(tm => tm.Morph.displayName.Equals(morphName)) != null)
                {
                    SuperController.LogMessage($"'{morphName}' has already been added for morph tracking");
                    return;
                }

                var generatedAtomName = TrackedMorphGeneratedAtomName(i, morphName);
                StartCoroutine(GetOrCreateEmptyAtom(generatedAtomName, (atom) =>
                {
                    if (atom != null)
                    {
                        UICreateMorphRow(i, morphName, true, atom.name, true);
                    }
                }));
            });

            // hidden form element to track how many morphs have been added
            TrackingCountJSON           = new JSONStorableFloat(TrackedMorphCountKey, 0, 0, 1000);
            TrackingCountJSON.storeType = JSONStorableParam.StoreType.Full;
            RegisterFloat(TrackingCountJSON);
        }