예제 #1
0
        private void AddPrerequisiteInformation(int newUpdateIndex, Identity newUpdateIdentity, XDocument updateXml)
        {
            var prerequisites = Prerequisite.FromXml(updateXml);

            if (prerequisites.Count > 0)
            {
                // Save this for later when we use prerequisites to resolve product and classification
                AddedPrerequisites.Add(newUpdateIdentity, prerequisites);
            }

            foreach (var prereq in prerequisites)
            {
                if (prereq is Simple)
                {
                    PrerequisitesList.Add(new KeyValuePair <int, List <Guid> >(newUpdateIndex, new List <Guid>()
                    {
                        (prereq as Simple).UpdateId
                    }));
                }
                else if (prereq is AtLeastOne)
                {
                    PrerequisitesList.Add(
                        new KeyValuePair <int, List <Guid> >(
                            newUpdateIndex,
                            new List <Guid>((prereq as AtLeastOne).Simple.Select(s => s.UpdateId))));

                    if ((prereq as AtLeastOne).IsCategory)
                    {
                        // Add an empty guid at the end to mark that this atLeast group is a category group
                        PrerequisitesList.Last().Value.Add(Guid.Empty);
                    }
                }
            }
        }
        public static void AddPrerequisite(this ModelBuilder builder, Prerequisite prerequisite, BasePrerequisiteBinding binding)
        {
            binding.PrerequisiteId = prerequisite.Id;
            prerequisite.BindingId = binding.Id;

            builder.AddData(binding.GetType(), binding);

            switch (prerequisite)
            {
            case ChoicePrerequisite choicePrerequisite:
                foreach (Prerequisite innerPrerequisite in choicePrerequisite.Choices)
                {
                    builder.AddPrerequisite(innerPrerequisite, new ChoicePrerequisiteBinding {
                        Id = innerPrerequisite.Id, ChoiceId = choicePrerequisite.Id
                    });
                }

                choicePrerequisite.Choices = Array.Empty <Prerequisite>();
                break;

            case CombinedPrerequisite combinedPrerequisite:
                foreach (Prerequisite innerPrerequisite in combinedPrerequisite.Entries)
                {
                    builder.AddPrerequisite(innerPrerequisite, new CombinedPrerequisiteBinding {
                        Id = innerPrerequisite.Id, CombinationId = combinedPrerequisite.Id
                    });
                }
                combinedPrerequisite.Entries = Array.Empty <Prerequisite>();
                break;
            }

            builder.Entity(prerequisite.GetType()).HasData(prerequisite);
        }
        public JsonResponse Create(Prerequisite prerequisite)
        {
            if (prerequisite == null)
            {
                return(new JsonResponse {
                    Result = "Failed",
                    Message = "Create requires an instance of PreRequisites"
                });
            }
            if (!ModelState.IsValid)
            {
                return(new JsonResponse {
                    Result = "Failed",
                    Message = "Model state is invalid. See data.",
                    Error = ModelState
                });
            }

            db.Prerequisites.Add(prerequisite);
            db.SaveChanges();
            return(new JsonResponse {
                Message = "Create successful.",
                Data = prerequisite
            });
        }
 static void Postfix(Prerequisite __instance, ref bool __result, ref bool?__state)
 {
     if (__state ?? IsAvailable(__instance.GetType()))
     {
         __result = true;
     }
 }
 public void RepairSets(FocusModel focus, List <FocusModel> fociList)
 {
     //Relative ids
     if (focus.CoordinatesRelativeTo != null)
     {
         CoordinatesRelativeTo = fociList.FirstOrDefault(f => f.UniqueName
                                                         == focus.CoordinatesRelativeTo.UniqueName);
     }
     //Prerequisites
     foreach (PrerequisitesSetModel set in focus.Prerequisite)
     {
         //Add the linked focus
         PrerequisitesSetModel prerequiste = new PrerequisitesSetModel(
             fociList.FirstOrDefault(f => f.UniqueName == set.Focus.UniqueName));
         //Run through all the parents and add them
         foreach (FocusModel parent in set.FociList)
         {
             prerequiste.FociList.Add(
                 fociList.FirstOrDefault(f => f.UniqueName == parent.UniqueName));
         }
         Prerequisite.Add(prerequiste);
     }
     //Mutually exclusives
     foreach (MutuallyExclusiveSetModel set in focus.MutualyExclusive)
     {
         //Create the set with both foci
         MutualyExclusive.Add(new MutuallyExclusiveSetModel(
                                  fociList.FirstOrDefault(f => f.UniqueName == set.Focus1.UniqueName),
                                  fociList.FirstOrDefault(f => f.UniqueName == set.Focus2.UniqueName)));
     }
 }
 public void MergeFrom(ProfessionNodeLevel other)
 {
     if (other == null)
     {
         return;
     }
     if (other.BuffGmtId.Length != 0)
     {
         BuffGmtId = other.BuffGmtId;
     }
     if (other.prerequisite_ != null)
     {
         if (prerequisite_ == null)
         {
             Prerequisite = new global::WUProtos.Data.Requirements();
         }
         Prerequisite.MergeFrom(other.Prerequisite);
     }
     if (other.cost_ != null)
     {
         if (cost_ == null)
         {
             Cost = new global::WUProtos.Data.Loot.LootCollection();
         }
         Cost.MergeFrom(other.Cost);
     }
     mapAbilities_.Add(other.mapAbilities_);
     if (other.RankPoints != 0)
     {
         RankPoints = other.RankPoints;
     }
     _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
 }
예제 #7
0
    /**
     * Arrive in the node:
     * - Interact with the prop if it's enabled;
     * - Make this object interactable if prerequisite is met.
     */
    public override void Arrive()
    {
        if (inter != null && inter.enabled)
        {
            inter.Interact();
            return;
        }
        PathReactor path = GetComponent <PathReactor>();

        if (path == null || path.switcher.state)
        {
            base.Arrive();
        }

        // Make this object interactable if prerequisite is met
        if (inter != null)
        {
            Prerequisite pre = GetComponent <Prerequisite>();
            if (pre && !inter.inspectObject && !pre.Complete)
            {
                return;
            }
            col.enabled   = true;
            inter.enabled = true;
            changeMouseIcon();
        }
    }
예제 #8
0
        public IHttpActionResult PutPrerequisite(int id, Prerequisite prerequisite)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != prerequisite.Id)
            {
                return(BadRequest());
            }

            db.Entry(prerequisite).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!PrerequisiteExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
        public override int GetHashCode()
        {
            int hash = 1;

            if (BuffGmtId.Length != 0)
            {
                hash ^= BuffGmtId.GetHashCode();
            }
            if (prerequisite_ != null)
            {
                hash ^= Prerequisite.GetHashCode();
            }
            if (cost_ != null)
            {
                hash ^= Cost.GetHashCode();
            }
            hash ^= mapAbilities_.GetHashCode();
            if (RankPoints != 0)
            {
                hash ^= RankPoints.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
        public ActionResult Create(CourseViewModel courseViewModel)
        {
            Course            course        = courseViewModel.Course;
            IEnumerable <int> prerequisites = courseViewModel.PrerequisiteIds;

            try
            {
                course = courseService.Add(course);
                if (prerequisites != null)
                {
                    foreach (int prerequisiteId in prerequisites)
                    {
                        Prerequisite prerequisite = new Prerequisite
                        {
                            CourseId             = course.Id,
                            CoursePrerequisiteId = prerequisiteId
                        };
                        prerequisiteService.Add(prerequisite);
                    }
                }
                return(RedirectToAction("Index"));
            }
            catch (Exception ex)
            {
                return(View(courseViewModel));
            }
        }
예제 #11
0
 /// <summary>
 /// To create a category
 /// </summary>
 /// <param name="categoryObj">Category Object</param>
 public void Post(Prerequisite categoryObj)
 {
     try
     {
         ServiceFactory.GetPrerequisite().Create(categoryObj);
     }
     catch (Exception ex) {}
 }
        public ActionResult DeleteConfirmed(int id)
        {
            Prerequisite prerequisite = db.Prerequisites.Find(id);

            db.Prerequisites.Remove(prerequisite);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
예제 #13
0
        public void Configure(Action<Prerequisite> action)
        {
            var prerequisite = new Prerequisite();
            action(prerequisite);
            _prerequisites.Add(prerequisite);

               _rules.Add(prerequisite.Rule);
        }
예제 #14
0
 public static bool AddPrereq(Prerequisite prereq)
 {
     using (var connection = DbConn.GetConnection())
     {
         connection.Open();
         return(AddPrereq(connection, prereq));
     }
 }
 static bool Prefix(Prerequisite __instance, ref bool?__state)
 {
     if ((__state = IsAvailable(__instance.GetType())).Value)
     {
         return(false);
     }
     return(true);
 }
예제 #16
0
 /// <summary>
 /// To Update a category
 /// </summary>
 /// <param name="id">CategoryId</param>
 /// <param name="categoryObj">category Object</param>
 public void Put(string id, Prerequisite categoryObj)
 {
     try
     {
         categoryObj.Id = new Guid(id);
         ServiceFactory.GetPrerequisite().Update(categoryObj);
     }
     catch (Exception exp) {}
 }
예제 #17
0
 /**
 *Deafult object interaction
 */
 public virtual void Interact() {
     pre = GetComponent<Prerequisite>();
     if (pre && !pre.Complete) {
         Debug.Log(message);
         interact = false;
         return;
     }
     interact = true;
 }
예제 #18
0
            internal static Prerequisite Read(Stream input, Endian endian)
            {
                var instance = new Prerequisite();

                instance.Name        = input.ReadValueU32(endian);
                instance.RewardIndex = input.ReadValueS32(endian);
                instance.Tag         = input.ReadValueU32(endian);
                return(instance);
            }
예제 #19
0
        public static void UpdatePrerequisite(Prerequisite p)
        {
            using (IDbConnection conn = new SqlConnection(Connection))
            {
                string sql = "UPDATE PREREQUISITE SET parent_id = @ParentId, child_id = @ChildId " +
                             "WHERE prerequisite_id = @PrerequisiteId;";

                conn.Query(sql, p);
            }
        }
 public ActionResult Edit([Bind(Include = "ID,PrereqName,BaseCourse_PreReqIsFor_ID")] Prerequisite prerequisite)
 {
     if (ModelState.IsValid)
     {
         db.Entry(prerequisite).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     ViewBag.BaseCourse_PreReqIsFor_ID = new SelectList(db.BaseCourses, "ID", "Name", prerequisite.BaseCourse_PreReqIsFor_ID);
     return(View(prerequisite));
 }
예제 #21
0
 /**
  * Deafult object interaction
  */
 public virtual void Interact()
 {
     pre = GetComponent <Prerequisite>();
     if (pre && !pre.Complete)
     {
         Debug.Log(message);
         interact = false;
         return;
     }
     interact = true;
 }
예제 #22
0
        public IHttpActionResult GetPrerequisite(int id)
        {
            Prerequisite prerequisite = db.Prerequisites.Find(id);

            if (prerequisite == null)
            {
                return(NotFound());
            }

            return(Ok(prerequisite));
        }
예제 #23
0
        public IHttpActionResult PostPrerequisite(Prerequisite prerequisite)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            db.Prerequisites.Add(prerequisite);
            db.SaveChanges();

            return(CreatedAtRoute("DefaultApi", new { id = prerequisite.Id }, prerequisite));
        }
예제 #24
0
        public ActionResult AddPreReq(int?id, string preReqName)
        {
            BaseCourse   bc     = db.BaseCourses.Find(id);
            Prerequisite prereq = new Prerequisite();

            prereq.BaseCourse_PreReqIsFor = bc;
            prereq.PrereqName             = preReqName;
            db.Prerequisites.Add(prereq);
            bc.Prerequisites.Add(prereq);
            db.Entry(bc).State = EntityState.Modified;
            db.SaveChanges();
            return(RedirectToAction("Details", new { id = bc.ID }));
        }
예제 #25
0
 public void Delete()
 {
     //Kill the focus sets
     foreach (MutuallyExclusiveSet set in MutualyExclusive.ToList())
     {
         set.DeleteSetRelations();
     }
     foreach (PrerequisitesSet set in Prerequisite.ToList())
     {
         set.DeleteSetRelations();
     }
     Messenger.Default.Send(new NotificationMessage(this, "DeleteFocus"));
 }
예제 #26
0
        public ResearchTechStep(TechType target, IEnumerable <Prerequisite> extraPrerequisites)
        {
            Research     = TechTypes.All[target];
            ResearchedBy = Research.WhatResearches.Type;

            var defaultPrerequisites = new Prerequisite[]
            {
                new BuildingExistsPrerequisite(ResearchedBy),
                new ResourcePrerequisite(Research.Price.Minerals, Research.Price.Gas)
            };

            Prerequisites = defaultPrerequisites.Concat(extraPrerequisites).ToList();
            Target        = target;
        }
        // GET: Prerequisites/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Prerequisite prerequisite = db.Prerequisites.Find(id);

            if (prerequisite == null)
            {
                return(HttpNotFound());
            }
            return(View(prerequisite));
        }
예제 #28
0
 public RegularLine(XmlElement element, LineCatalogue catalogue, Conversation conversation)
     : base(element, catalogue, conversation)
 {
     text = element.GetAttribute("text");
     speakerName = element.GetAttribute("speaker");
     if (speakerName.Equals("")){
         speakerName = "Abby";
     }
     prerequisite = new Prerequisite(element.GetAttribute("prerequisite"), speakerName, conversation);
     consequence = new Consequence(element.GetAttribute("consequence"), speakerName, conversation);
     cameraAngle = CameraAngle.GetCameraAngle(element.GetAttribute("camera_angle"));
     emotion = Emotion.GetEmotion(element.GetAttribute("expression"));
     id = element.GetAttribute("id");
 }
        public ResearchUpgradeStep(UpgradeType target, IEnumerable <Prerequisite> extraPrerequisites)
        {
            Research     = UpgradeTypes.All[target];
            ResearchedBy = Research.WhatUpgrades.Type;

            var defaultPrerequisites = new Prerequisite[]
            {
                new BuildingExistsPrerequisite(ResearchedBy),
                new ResourcePrerequisite(Research.MineralPrice(0), Research.GasPrice(0)),
            };

            Prerequisites = defaultPrerequisites.Concat(extraPrerequisites).ToList();
            Target        = target;
        }
예제 #30
0
    /**
     * Move to the next Scene
     * - Plays an animation if exists
     */
    public override void Interact()
    {
        Prerequisite pre = GetComponent <Prerequisite>();

        if (pre && !pre.Complete)
        {
            return;
        }
        //anim.Play("OpeningDoor", -1, 0f);
        anim.SetBool("Open", true);
        Cursor.SetCursor(null, Vector2.zero, CursorMode.Auto);
        GameManager.gm.currentLevel = nextLevel;
        StartCoroutine(LoadingScene());
    }
예제 #31
0
        private void unlockPredefinedDesigns(MainGame game)
        {
            var playerTechs = game.States.DevelopmentAdvances.Of[this.Player];
            var techLevels  = playerTechs.ToDictionary(x => x.Topic.IdCode, x => (double)x.Level);

            foreach (var predefDesign in game.Statics.PredeginedDesigns)
            {
                if (!this.Player.UnlockedDesigns.Contains(predefDesign) && Prerequisite.AreSatisfied(predefDesign.Prerequisites(game.Statics), 0, techLevels))
                {
                    this.Player.UnlockedDesigns.Add(predefDesign);
                    makeDesign(game.Statics, game.States, predefDesign, techLevels);
                }
            }
        }
예제 #32
0
        public IHttpActionResult DeletePrerequisite(int id)
        {
            Prerequisite prerequisite = db.Prerequisites.Find(id);

            if (prerequisite == null)
            {
                return(NotFound());
            }

            db.Prerequisites.Remove(prerequisite);
            db.SaveChanges();

            return(Ok(prerequisite));
        }
예제 #33
0
 static public void RestrictPrerequisites(BlueprintArchetype archetype, UnitDescriptor unit, LevelUpState state)
 {
     if (IgnorePrerequisites.Ignore)
     {
         return;
     }
     for (int index = 0; index < archetype.ComponentsArray.Length; ++index)
     {
         Prerequisite components = archetype.ComponentsArray[index] as Prerequisite;
         if ((bool)((UnityEngine.Object)components))
         {
             components.Restrict((FeatureSelectionState)null, unit, state);
         }
     }
 }
예제 #34
0
파일: Binary.cs 프로젝트: virmitio/devtools
        /// <summary>
        ///   Synchronously loads the binary
        /// </summary>
        /// <param name="filename"> </param>
        /// <param name="loadOptions"> </param>
        private Binary(string filename, BinaryLoadOptions loadOptions)
        {
            _loadOptions = loadOptions;
            Filename = filename;
            IsPEFile = new Prerequisite<bool>(LoadPEInfo);

            Is64Bit = Is64BitPE = new Prerequisite<bool>(LoadPEInfo);
            Is32BitPE = new Prerequisite<bool>(LoadPEInfo);
            IsManaged = new Prerequisite<bool>(LoadPEInfo);
            IsNative = new Prerequisite<bool>(LoadPEInfo);

            Is32Bit = new Prerequisite<bool>(LoadPEInfo);
            IsAnyCpu = new Prerequisite<bool>(LoadPEInfo, () => IsPEFile && (Is32BitPE && IsManaged && ((CorHeader.Flags & 0x0002) == 0)));
            IsConsoleApp = new Prerequisite<bool>(LoadPEInfo, () => IsPEFile && (NtHeader.SubSystem & 1) == 1);

            ExecutableInformation = new Prerequisite<ExecutableInfo>(LoadPEInfo, () => {
                var result = IsManaged ? ExecutableInfo.managed : ExecutableInfo.native;
                if (IsAnyCpu) {
                    result |= ExecutableInfo.any;
                } else {
                    switch (CoffHeader.Machine) {
                        case 0x01c0:
                            result |= ExecutableInfo.arm;
                            break;
                        case 0x014c:
                            result |= ExecutableInfo.x86;
                            break;
                        case 0x0200:
                            result |= ExecutableInfo.ia64;
                            break;
                        case 0x8664:
                            result |= ExecutableInfo.x64;
                            break;
                        default:
                            throw new CoAppException("Unrecognized Executable Machine Type.");
                    }
                }
                return result;
            });

            VersionInfo = new Prerequisite<FileVersionInfo>(LoadVersionInfo);

            MD5 = new Prerequisite<string>(LoadMD5);

            ILOnly = new Prerequisite<bool>(LoadManagedData);

            NativeResources = new Prerequisite<ResourceInfo>(LoadResourceData);
            Manifest = new Prerequisite<NativeManifest>(LoadManifestData);

            IsSigned = new Prerequisite<bool>(LoadSignature);
            IsValidSigned = new Prerequisite<bool>(LoadSignature);

            IsStrongNamed = new Prerequisite<bool>(LoadManagedData);
            AssemblyCulture = new Prerequisite<string>(LoadManagedData);
            AssemblyVersion = new Prerequisite<FourPartVersion>(LoadManagedData);

            IsDelaySigned = new Prerequisite<bool>(LoadManagedData);

            LoadData();
        }