コード例 #1
1
ファイル: ListViewSelectedKeeper.cs プロジェクト: xceza7/EDCB
        public void RestoreListViewSelected()
        {
            try
            {
                if (listBox != null && oldItem != null && oldItems != null)
                {
                    if (this.allSelected == true)
                    {
                        listBox.SelectAll();
                        return;
                    }

                    //このUnselectAll()は無いと正しく復元出来ない状況があり得る
                    listBox.UnselectAll();

                    //上限越えの場合は、選択を解除して終了。
                    if (oldItems.Count >= this.MaxRestoreNum) return;

                    //選択数が少ないときは逆に遅くなる気もするが、Dictionaryにしておく
                    var listKeys = new Dictionary<ulong, object>();

                    if (getKey == null)
                    {
                        getKey = CtrlCmdDefEx.GetKeyFunc(oldItem.GetType());
                    }

                    foreach (object listItem1 in listBox.Items)
                    {
                        //重複するキーは基本的に無いという前提
                        try
                        {
                            listKeys.Add(getKey(listItem1), listItem1);
                        }
                        catch { }
                    }

                    object setItem;
                    if (listKeys.TryGetValue(getKey(oldItem), out setItem))
                    {
                        listBox.SelectedItem = setItem;
                    }

                    foreach (object oldItem1 in oldItems)
                    {
                        if (listKeys.TryGetValue(getKey(oldItem1), out setItem))
                        {
                            //数が多いとき、このAddが致命的に遅い
                            listBox.SelectedItems.Add(setItem);
                        }
                    }

                    //画面更新が入るので最後に実行する。SelectedItem==nullのときScrollIntoViewは何もしない。
                    listBox.ScrollIntoView(listBox.SelectedItem);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message + "\r\n" + ex.StackTrace);
            }
        }
コード例 #2
0
ファイル: BatArg.cs プロジェクト: seenen/HerosTechBak_Seenen
        public BatArg(Dictionary<string, string> keys)
        {
            Model = (BatModel)(int.Parse(keys["Model"]));
            Hierarchy = (DestHierarchy)(int.Parse(keys["DestHierarchy"]));
            PC = keys.ContainsKey("PC");
            IOS = keys.ContainsKey("IOS");
            AND = keys.ContainsKey("AND");
            if (keys.TryGetValue("SrcFolder", out SrcFolder))	
			{
				SrcFolder = Application.dataPath + SrcFolder;
				SrcFolder.Replace("\\", "/");
			}
            if (keys.TryGetValue("SrcFolderName", out SrcFolderName)) SrcFolderName.Replace("\\", "/");
            SearchLoop = keys.ContainsKey("SearchLoop");
            if (keys.TryGetValue("SearchPrefix", out SearchPrefix))	SearchPrefix.Replace("\\", "/");
            if (keys.TryGetValue("DestFolder", out DestFolderPath))	
			{
				DestFolderPath = Application.dataPath + "/../.." + DestFolderPath;
				DestFolderPath.Replace("\\", "/");
			}
            if (keys.TryGetValue("DestFolderName", out DestFolderName))	DestFolderName.Replace("\\", "/");
			
//			Debug.Log(JsonWriter.Serialize(this));

        }
コード例 #3
0
ファイル: HnDGeneralUtils.cs プロジェクト: priaonehaha/HnD
        /// <summary>
        /// Emails the given password to the given emailaddress. No username is specified.
        /// </summary>
        /// <param name="password">The password to email</param>
        /// <param name="emailAddress">The recipient's emailaddress.</param>
        /// <param name="emailTemplate">The email template.</param>
        /// <param name="emailData">The email data.</param>
        /// <returns>true if succeeded, false otherwise</returns>
        public static bool EmailPassword(string password, string emailAddress, string emailTemplate, Dictionary<string, string> emailData)
        {
            StringBuilder mailBody = new StringBuilder(emailTemplate);

            string applicationURL = string.Empty;
            emailData.TryGetValue("applicationURL", out applicationURL);

            if (!string.IsNullOrEmpty(emailTemplate))
            {
                // Use the existing template to format the body
                string siteName = string.Empty;
                emailData.TryGetValue("siteName", out siteName);

                mailBody.Replace("[URL]", applicationURL);
                mailBody.Replace("[SiteName]", siteName);
                mailBody.Replace("[Password]", password);
            }

            // format the subject
            string subject = string.Empty;
            emailData.TryGetValue("emailPasswordSubject", out subject);
            subject += applicationURL;

            string fromAddress = string.Empty;
            emailData.TryGetValue("defaultFromEmailAddress", out fromAddress);

            // send it
            // host and smtp credentials are set in .config file
            SmtpClient client = new SmtpClient();
            client.Send(fromAddress, emailAddress, subject, mailBody.ToString());
            return true;
        }
コード例 #4
0
ファイル: NCTunnelOverlap.cs プロジェクト: johnynek/brunet
    /// <summary>Returns at most the 4 closest addresses in order.</summary>
    protected List<Connection> GetClosest(List<Connection> cons)
    {
      List<Connection> closest = new List<Connection>(cons);

      // Since MeasuredLatency could change the duration of our sorting we make
      // a copy as necessary
      Dictionary<Connection, double> latencies = new Dictionary<Connection, double>();

      Comparison<Connection> comparer = delegate(Connection x, Connection y) {
        double lat_x, lat_y;
        if(!latencies.TryGetValue(x, out lat_x)) {
          lat_x = _ncservice.GetMeasuredLatency(x.Address);
          latencies[x] = lat_x;
        }
        if(!latencies.TryGetValue(y, out lat_y)) {
          lat_y = _ncservice.GetMeasuredLatency(y.Address);
          latencies[y] = lat_y;
        }

        // Remember that smaller is better but -1 is bad...
        // If either is smaller than 0 invert the comparison..
        if(lat_x < 0 || lat_y < 0) {
          return lat_y.CompareTo(lat_x);
        } else {
          return lat_x.CompareTo(lat_y);
        }
      };

      closest.Sort(comparer);
      if(closest.Count > 4) {
        closest.RemoveRange(4, closest.Count - 4);
      }
      return closest;
    }
コード例 #5
0
ファイル: Popup.cs プロジェクト: deltaDNA/unity-sdk
        public Popup(Dictionary<string, object> options)
        {
            object name;
            if (options.TryGetValue("name", out name)) {
                _name = (string)name;
            }

            object depth;
            if (options.TryGetValue("depth", out depth)) {
                _depth = (int)depth;
            }
        }
コード例 #6
0
        private static void ReadClassDataContractMembers(DataContractJsonSerializer serializer, ClassDataContract dataContract, Dictionary<string, object> deserialzedValue, object newInstance, XmlObjectSerializerReadContextComplexJson context)
        {
            if (dataContract.BaseContract != null)
            {
                ReadClassDataContractMembers(serializer, dataContract.BaseContract, deserialzedValue, newInstance, context);
            }
            for (int i = 0; i < dataContract.Members.Count; i++)
            {
                DataMember member = dataContract.Members[i];
                object currentMemberValue;
                if (deserialzedValue.TryGetValue(XmlConvert.DecodeName(dataContract.Members[i].Name), out currentMemberValue) ||
                    dataContract.IsKeyValuePairAdapter && deserialzedValue.TryGetValue(XmlConvert.DecodeName(dataContract.Members[i].Name.ToLowerInvariant()), out currentMemberValue))
                {
                    if (member.MemberType.GetTypeInfo().IsPrimitive || currentMemberValue == null)
                    {
                        SetMemberValue(newInstance, serializer.ConvertObjectToDataContract(member.MemberTypeContract, currentMemberValue, context), dataContract.Members[i].MemberInfo, dataContract.UnderlyingType);
                    }
                    else
                    {
                        context.PushKnownTypes(dataContract);
                        object subMemberValue = serializer.ConvertObjectToDataContract(member.MemberTypeContract, currentMemberValue, context);
                        Type declaredType = (member.MemberType.GetTypeInfo().IsGenericType && member.MemberType.GetGenericTypeDefinition() == Globals.TypeOfNullable)
                            ? Nullable.GetUnderlyingType(member.MemberType)
                            : member.MemberType;

                        if (!(declaredType == Globals.TypeOfObject && subMemberValue.GetType() == Globals.TypeOfObjectArray) && declaredType != subMemberValue.GetType())
                        {
                            DataContract memberValueContract = DataContract.GetDataContract(subMemberValue.GetType());
                            context.CheckIfTypeNeedsVerifcation(member.MemberTypeContract, memberValueContract);
                        }

                        if (member.IsGetOnlyCollection)
                        {
                            PopulateReadOnlyCollection(newInstance, member, (IEnumerable)subMemberValue);
                        }
                        else
                        {
                            SetMemberValue(newInstance, subMemberValue, dataContract.Members[i].MemberInfo, dataContract.UnderlyingType);
                        }
                        context.PopKnownTypes(dataContract);
                    }
                }
                else if (member.IsRequired)
                {
                    XmlObjectSerializerWriteContext.ThrowRequiredMemberMustBeEmitted(dataContract.MemberNames[i].Value, dataContract.UnderlyingType);
                }
            }
        }
コード例 #7
0
        public static TypeSummary[] BuildSummary(MigrationReport report)
        {
            IDictionary<string, TypeSummary> types = new Dictionary<string, TypeSummary>();

            foreach (MigrationReportMessage message in report.Messages)
            {
                TypeSummary type;
                string sourceType = message.SourceType ?? string.Empty;

                if (!types.TryGetValue(sourceType, out type))
                {
                    type = new TypeSummary(sourceType);
                    types.Add(sourceType, type);
                }

                type.AddMessage(message);
            }

            int typeCount = types.Count;
            string[] keys = new string[typeCount];
            TypeSummary[] values = new TypeSummary[typeCount];
            types.Keys.CopyTo(keys, 0);
            types.Values.CopyTo(values, 0);
            Array.Sort(keys, values);
            return values;
        }
コード例 #8
0
ファイル: GridBuilder.cs プロジェクト: jschiff/SphericalHorse
        private void InstantiatePrefabs(Vector3[,] worldPositions, string[,] map, Dictionary<string, GameObject> objectDictionary)
        {
            int width = map.GetLength(0);
            int height = map.GetLength(1);

            GameObject container = new GameObject("Generated Map Container");
            container.transform.parent = this.transform;
            Dictionary<string, GameObject> containerDictionary = new Dictionary<string, GameObject>(objectDictionary.Keys.Count);
            foreach (string typeName in objectDictionary.Keys) {
            GameObject typeContainer = new GameObject(typeName);
            typeContainer.transform.parent = container.transform;
            containerDictionary.Add(typeName, typeContainer);
            }

            container.transform.parent = this.transform;
            for (int i = 0; i < width; i++) {
            for (int j = 0; j < height; j++) {
                string mapValue = map[i, j];

                GameObject prefab;
                if (mapValue != null && objectDictionary.TryGetValue(mapValue, out prefab)) {
                    GameObject instance = (GameObject)Instantiate(prefab);
                    instance.transform.position = worldPositions[i, j];
                    instance.transform.parent = containerDictionary[mapValue].transform;

                    if (instance.CompareTag("Player")) {
                        player = instance;
                    }
                }
            }
            }
        }
コード例 #9
0
ファイル: LoginForm.cs プロジェクト: hamptons/PlaceYourBets
        // TODO: Insert code to perform custom authentication using the provided username and password
        // (See http://go.microsoft.com/fwlink/?LinkId=35339).
        // The custom principal can then be attached to the current thread's principal as follows:
        //     My.User.CurrentPrincipal = CustomPrincipal
        // where CustomPrincipal is the IPrincipal implementation used to perform authentication.
        // Subsequently, My.User will return identity information encapsulated in the CustomPrincipal object
        // such as the username, display name, etc.
        private void loginButton_Click(System.Object sender, System.EventArgs e)
        {
            FixtureBuilder fb = new FixtureBuilder();

            Dictionary<string, int> userDictionary = new Dictionary<string, int>();
            userDictionary = fb.getUsersAndIds();

            string username = usernameTextBox.Text.ToLower();
            userId = -1;

            if (string.IsNullOrEmpty(username)) {
                Interaction.MsgBox("Please enter your username");

            } else {
                if (userDictionary.ContainsKey(username)) {
                    userDictionary.TryGetValue(username, out userId);
                    My.MyProject.Forms.FixturesForm.currentUser = userId;
                    My.MyProject.Forms.MenuForm.Show();
                    this.Close();
                } else {
                    Interaction.MsgBox("Username not recognised");
                    usernameTextBox.Clear();
                }

            }
        }
コード例 #10
0
        private static object GenerateComplexObject(Type type, Dictionary<Type, object> createdObjectReferences)
        {
            object result = null;

            if (createdObjectReferences.TryGetValue(type, out result))
            {
                return result;
            }

            if (type.IsValueType)
            {
                result = Activator.CreateInstance(type);
            }
            else
            {
                ConstructorInfo defaultCtor = type.GetConstructor(Type.EmptyTypes);
                if (defaultCtor == null)
                {
                    return null;
                }

                result = defaultCtor.Invoke(new object[0]);
            }
            createdObjectReferences.Add(type, result);
            SetPublicProperties(type, result, createdObjectReferences);
            SetPublicFields(type, result, createdObjectReferences);
            return result;
        }
コード例 #11
0
ファイル: TermVector.cs プロジェクト: tristanstcyr/SPIMI
        public static TermVector GetCentroid(IEnumerable<TermVector> vectors)
        {
            Dictionary<string, long> sum = new Dictionary<string, long>();

            int vectorCount = 0;
            // Sum the lengths of dimensions
            foreach (TermVector vector in vectors)
            {
                vectorCount++;
                foreach (string term in vector.Terms)
                {
                    long count = 0;
                    sum.TryGetValue(term, out count);
                    sum.Remove(term);
                    sum.Add(term, count + vector.GetDimensionLength(term));
                }
            }

            // Divide the dimensions
            Dictionary<string, int> centroid = new Dictionary<string, int>();
            foreach (KeyValuePair<string, long> dimension in sum)
            {
                centroid.Add(dimension.Key, (int)(dimension.Value / vectorCount));
            }

            return new TermVector(centroid);
        }
コード例 #12
0
        /// <summary>
        /// Function to add a new material reference and returning its index in the material reference array.
        /// </summary>
        /// <param name="material"></param>
        /// <param name="fontAsset"></param>
        /// <param name="materialReferences"></param>
        /// <param name="materialReferenceIndexLookup"></param>
        /// <returns></returns>
        public static int AddMaterialReference(Material material, TMP_FontAsset fontAsset, MaterialReference[] materialReferences, Dictionary<int, int> materialReferenceIndexLookup)
        {
            int materialID = material.GetInstanceID();
            int index = 0;

            if (materialReferenceIndexLookup.TryGetValue(materialID, out index))
            {
                return index;
            }
            else
            {
                index = materialReferenceIndexLookup.Count;

                // Add new reference index
                materialReferenceIndexLookup[materialID] = index;

                materialReferences[index].index = index;
                materialReferences[index].fontAsset = fontAsset;
                materialReferences[index].spriteAsset = null;
                materialReferences[index].material = material;
                materialReferences[index].isDefaultMaterial = materialID == fontAsset.material.GetInstanceID() ? true : false;
                //materialReferences[index].padding = 0;
                materialReferences[index].referenceCount = 0;

                return index;
            }
        }
コード例 #13
0
ファイル: CalendarHelper.cs プロジェクト: linguado/mundo-site
 public static IEnumerable<RegionalNode> PrepareRegional(IEnumerable<ScheduleInfo> model,out Dictionary<DayOfWeek,String> days)
 {
     var result = new Dictionary<String, RegionalNode>();
     days = new Dictionary<DayOfWeek, string>(7);
     var mappings = new Dictionary<DayOfWeek, String>
                {
                    {DayOfWeek.Monday, GSchedule.Mo},
                    {DayOfWeek.Tuesday, GSchedule.Tu},
                    {DayOfWeek.Wednesday, GSchedule.We},
                    {DayOfWeek.Thursday, GSchedule.Th},
                    {DayOfWeek.Friday, GSchedule.Fr},
                    {DayOfWeek.Saturday, GSchedule.Sa},
                    {DayOfWeek.Sunday, GSchedule.Su},
                };
     foreach (var item in model)
     {
         var time = String.Format("{0:hh\\:mm}-{1:hh\\:mm}", item.Starts, item.Ends);
         RegionalNode node;
         if (!result.TryGetValue(time, out node))
         {
             result[time] = node = new RegionalNode(time);
         }
         node.AddItem(item);
         var dayOfWeek = (DayOfWeek) item.Day;
         if (!days.ContainsKey(dayOfWeek))
         {
             days.Add(dayOfWeek,mappings[dayOfWeek]);
         }
     }
     return result.Values;
 }
コード例 #14
0
 public void Init(IDictionary<DateTime, int> dates, DateTime selectedDate)
 {
   Dictionary<int, TreeNode> dictionary1 = new Dictionary<int, TreeNode>();
   Dictionary<int, TreeNode> dictionary2 = new Dictionary<int, TreeNode>();
   this.treeView.BeginUpdate();
   foreach (KeyValuePair<DateTime, int> keyValuePair in (IEnumerable<KeyValuePair<DateTime, int>>) dates)
   {
     DateTime key = keyValuePair.Key;
     int year = key.Year;
     int month = key.Month;
     int day = key.Day;
     TreeNode node1;
     if (!dictionary1.TryGetValue(year, out node1))
     {
       node1 = (TreeNode) new DateNode(key, "yyyy");
       dictionary1.Add(year, node1);
       this.treeView.Nodes.Add(node1);
     }
     TreeNode node2;
     if (!dictionary2.TryGetValue(month, out node2))
     {
       node2 = (TreeNode) new DateNode(key, "MMM");
       dictionary2.Add(month, node2);
       node1.Nodes.Add(node2);
     }
     DayNode dayNode = new DayNode(key, keyValuePair.Value);
     node2.Nodes.Add((TreeNode) dayNode);
     if (key == selectedDate)
       this.treeView.SelectedNode = (TreeNode) dayNode;
   }
   this.treeView.TreeViewNodeSorter = (IComparer) new DateNodeComparer();
   this.treeView.Sort();
   this.treeView.EndUpdate();
   this.UpdateOKButtonStatus();
 }
コード例 #15
0
ファイル: ObjectFactory.cs プロジェクト: Fedorm/core-master
        Type FindType(string @namespace, string name)
        {
            if (_types == null)
            {
                _types = new Dictionary<string, Dictionary<string, Type>>();
                foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
                    foreach (Type type in a.GetTypes())
                    {
                        var attribute = type.GetCustomAttribute<MarkupElementAttribute>(false);
                        if (attribute != null)
                        {
                            Dictionary<string, Type> typesInNamespace;
                            if (!_types.TryGetValue(attribute.NameSpace, out typesInNamespace))
                            {
                                typesInNamespace = new Dictionary<string, Type>();
                                _types.Add(attribute.NameSpace, typesInNamespace);
                            }
                            typesInNamespace.Add(attribute.Name, type);
                        }
                    }
            }

            try
            {
                return _types[@namespace][name];
            }
            catch (KeyNotFoundException e)
            {
                throw new Exception(String.Format("Type '{0}.{1}' is not found.", @namespace, name), e);
            }
        }
コード例 #16
0
		private static bool register(Dictionary<string, List<Pair>> events, string eventname, object obj, string funcname)
		{
			deregister(events, eventname, obj, funcname);
			List<Pair> lst = null;
			
			Pair pair = new Pair();
			pair.obj = obj;
			pair.funcname = funcname;
			pair.method = obj.GetType().GetMethod(funcname);
			if(pair.method == null)
			{
				Dbg.ERROR_MSG("Event::register: " + obj + "not found method[" + funcname + "]");
				return false;
			}
			
			Monitor.Enter(events);
			if(!events.TryGetValue(eventname, out lst))
			{
				lst = new List<Pair>();
				lst.Add(pair);
				Dbg.DEBUG_MSG("Event::register: event(" + eventname + ")!");
				events.Add(eventname, lst);
				Monitor.Exit(events);
				return true;
			}
			
			Dbg.DEBUG_MSG("Event::register: event(" + eventname + ")!");
			lst.Add(pair);
			Monitor.Exit(events);
			return true;
		}
コード例 #17
0
        public static object ConvertDictionaryToClassDataContract(DataContractJsonSerializer serializer, ClassDataContract dataContract, Dictionary<string, object> deserialzedValue, XmlObjectSerializerReadContextComplexJson context)
        {
            if (deserialzedValue == null)
            {
                return null;
            }

            if (dataContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
            {
                var tuple = deserialzedValue["DateTime"] as Tuple<DateTime, string>;
                DateTimeOffset dto = new DateTimeOffset(tuple != null ? tuple.Item1 : (DateTime)deserialzedValue["DateTime"]);
                return dto.ToOffset(new TimeSpan(0, (int)deserialzedValue["OffsetMinutes"], 0));
            }

            object serverTypeStringValue;
            if (deserialzedValue.TryGetValue(JsonGlobals.ServerTypeString, out serverTypeStringValue))
            {
                dataContract = ResolveDataContractFromTypeInformation(serverTypeStringValue.ToString(), dataContract, context);
            }

            object o = CreateInstance(dataContract);

            CheckDuplicateNames(dataContract);
            DataContractJsonSerializer.InvokeOnDeserializing(o, dataContract, context);
            ReadClassDataContractMembers(serializer, dataContract, deserialzedValue, o, context);
            DataContractJsonSerializer.InvokeOnDeserialized(o, dataContract, context);
            if (dataContract.IsKeyValuePairAdapter)
            {
                return dataContract.GetKeyValuePairMethodInfo.Invoke(o, Array.Empty<Type>());
            }
            return o;
        }
コード例 #18
0
ファイル: isosphere.cs プロジェクト: kharbechteinn/Scatterer
		// return index of point in the middle of p1 and p2
		private static int getMiddlePoint(int p1, int p2, ref List<Vector3> vertices, ref Dictionary<long, int> cache, float altitude)
		{
			// first check if we have it already
			bool firstIsSmaller = p1 < p2;
			long smallerIndex = firstIsSmaller ? p1 : p2;
			long greaterIndex = firstIsSmaller ? p2 : p1;
			long key = (smallerIndex << 32) + greaterIndex;
			
			int ret;
			if (cache.TryGetValue(key, out ret))
			{
				return ret;
			}
			
			// not in cache, calculate it
			Vector3 point1 = vertices[p1];
			Vector3 point2 = vertices[p2];
			Vector3 middle = new Vector3
				(
					(point1.x + point2.x) / 2f,
					(point1.y + point2.y) / 2f,
					(point1.z + point2.z) / 2f
					);
			
			// add vertex makes sure point is on unit sphere
			int i = vertices.Count;
			vertices.Add(middle.normalized * altitude);
			
			// store it, return index
			cache.Add(key, i);
			
			return i;
		}
コード例 #19
0
ファイル: NTTHashTable.cs プロジェクト: sadit/natix
 /// <summary>
 /// Returns items in at least MinT lists. The output is not necessarily sorted.
 /// </summary>
 public void SearchTThreshold(IList<IList<int>> lists, int MinT, out IList<int> docs, out IList<short> cardinalities)
 {
     var L = new Dictionary<int,short> ();
     var output_set = new HashSet<int> ();
     int i = 0;
     foreach (var list in lists) {
         foreach (var item in list) {
             short counter;
             if (L.TryGetValue (item, out counter)) {
                 counter++;
             } else {
                 /*if (MinT < i) {
                     continue;
                 }*/
                 counter = 1;
             }
             if (counter == MinT) {
                 output_set.Add (item);
             }
             L [item] = counter;
         }
         i++;
     }
     docs = new int[ output_set.Count ];
     cardinalities = new short[ docs.Count ];
     i = 0;
     foreach (var item in output_set) {
         docs [i] = item;
         cardinalities [i] = L [item];
         i++;
     }
     if (this.sorted_output) {
         Sorting.Sort<int,short> (docs, cardinalities);
     }
 }
コード例 #20
0
ファイル: UnitTraits.cs プロジェクト: eglo/HCRMod
        //*****************************************************************************************
        //add a new random postive trait to unit
        private bool addPositiveTrait(APlayableEntity unit)
        {
            Dbg.trc(Dbg.Grp.Units, 5);

            List<string> posPrefs = new List<string> {"trait.hardworker","trait.goodvision","trait.charismatic","trait.courageous","trait.athletic","trait.quicklearner","trait.strongback"};
            List<string> notHasPrefs = new List<string>();
            foreach(string pref in posPrefs) {
                if(unit.preferences[pref] != true) {
                    notHasPrefs.Add(pref);
                }
            }
            if(notHasPrefs.Count >= 1) {
                Dictionary<string,string> traitsChangedStrings = new Dictionary<string,string>{
                    {"trait.hardworker","is a hard worker"},
                    {"trait.goodvision","has good vision"},
                    {"trait.charismatic","is charismatic"},
                    {"trait.courageous","is courageous"},
                    {"trait.athletic","is athletic"},
                    {"trait.quicklearner","is a quick learner"},
                    {"trait.strongback","has a strong back"},
                };
                int add = UnityEngine.Random.Range(0, notHasPrefs.Count - 1);
                unit.preferences[notHasPrefs[add]] = true;
                string outString;
                traitsChangedStrings.TryGetValue(notHasPrefs[add], out outString);
                UI.print("All this training paid off! " + unit.unitName + " now " + outString + "!");
                return true;
            }
            return false;
        }
コード例 #21
0
        private double GetTeamWinPercentage(Team team, Dictionary<Guid, WinLossRecord> winLossRecords)
        {
            // Option 1: Total wins/losses, giving players who have played more a higher weight in the rating
            //			var record = new WinLossRecord();
            //			foreach (var player in team.Members)
            //			{
            //				WinLossRecord winLossRecord;
            //				if (winLossRecords.TryGetValue(player.Id, out winLossRecord))
            //				{
            //					record.Wins += winLossRecord.Wins;
            //					record.Losses += winLossRecord.Losses;
            //					record.Ties += winLossRecord.Ties;
            //				}
            //			}
            //			return record.WinPercentage;

            // Option 2: Average win percentage, equally weighted
            double winPercentage = 0.0;
            foreach (var player in team.Members)
            {
                WinLossRecord winLossRecord;
                if (winLossRecords.TryGetValue(player.Id, out winLossRecord))
                {
                    winPercentage += winLossRecord.WinPercentage;
                }
                else
                {
                    winPercentage += 0.5;
                }
            }

            return winPercentage/team.Members.Count;
        }
コード例 #22
0
ファイル: PNGImporter.cs プロジェクト: jschiff/SphericalHorse
        public static string[,] buildMatrix(Dictionary<Color, string> dictionary, PngReader reader)
        {
            ImageInfo info = reader.ImgInfo;
            var matrix = new string[info.Cols, info.Rows];

            for (int i = 0; i < info.Rows; i++) {
            ImageLine line = reader.ReadRow(i);
            int[] lineInts = line.Scanline;

            for (int j = 0, col = 0; j < lineInts.Length; j += info.Channels, col++) {
                int red = lineInts[j];
                int green = lineInts[j + 1];
                int blue = lineInts[j + 2];
                int alpha = 255;

                if (info.Channels == 4) {
                    alpha = lineInts[j + 3];
                }

                Color color = new Color(red / 255f, green / 255f, blue / 255f, alpha / 255f);
                string val;
                if (dictionary.TryGetValue(color, out val)) {
                    matrix[col, i] = val;
                }
            }
            }

            return matrix;
        }
コード例 #23
0
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    public MiResultValueTuple (string variable, List<MiResultValue> values)
      : base (variable)
    {
      if (values == null)
      {
        throw new ArgumentNullException ("values");
      }

      m_valueList = values;

      // 
      // Build a searchable dictionary of available result variables (fields).
      // 

      m_fieldDictionary = new Dictionary<string, List <MiResultValue>> ();

      foreach (MiResultValue value in m_valueList)
      {
        List <MiResultValue> fieldList;

        if (!m_fieldDictionary.TryGetValue (value.Variable, out fieldList))
        {
          fieldList = new List <MiResultValue> ();
        }

        fieldList.Add (value);

        m_fieldDictionary [value.Variable] = fieldList;
      }
    }
コード例 #24
0
ファイル: TimerThread.cs プロジェクト: GodLesZ/ZeusEngine
        public static void DumpInfo(TextWriter tw)
        {
            for (var i = 0; i < 8; ++i) {
                tw.WriteLine("Priority: {0}", (TimerPriority)i);
                tw.WriteLine();

                var hash = new Dictionary<string, List<Timer>>();

                for (var j = 0; j < mTimers[i].Count; ++j) {
                    var t = mTimers[i][j];

                    var key = t.ToString();

                    List<Timer> list;
                    hash.TryGetValue(key, out list);

                    if (list == null) {
                        hash[key] = list = new List<Timer>();
                    }

                    list.Add(t);
                }

                foreach (var kv in hash) {
                    var key = kv.Key;
                    var list = kv.Value;

                    tw.WriteLine("Type: {0}; Count: {1}; Percent: {2}%", key, list.Count, (int)(100 * (list.Count / (double)mTimers[i].Count)));
                }

                tw.WriteLine();
                tw.WriteLine();
            }
        }
コード例 #25
0
ファイル: LSHashTable.cs プロジェクト: malimu/CrisisTracker
        public void SetNewHashFunction(LSHashFunction hashFunction)
        {
            lock (accessLock)
            {
                Dictionary<CustomBitArray, LSHashTableCell> oldValues = _values;
                _values = new Dictionary<CustomBitArray, LSHashTableCell>();
                _hashFunction = hashFunction;

                //Re-hash all the old tweets using the new hash function
                foreach (LSHashTableCell oldCell in oldValues.Values)
                {
                    foreach (LSHashTweet tweet in oldCell.GetTweets())
                    {
                        bool anyTrue = false;
                        CustomBitArray hash = _hashFunction.CalculateHashScore(tweet.Vector, out anyTrue);
                        LSHashTableCell cell;
                        if (_values.TryGetValue(hash, out cell))
                        {
                            cell.Add(tweet);
                        }
                        else
                        {
                            cell = new LSHashTableCell(_cellCapacity);
                            cell.Add(tweet);
                            _values.Add(hash, cell);
                        }
                    }
                }
            }
        }
コード例 #26
0
ファイル: Analysis.cs プロジェクト: plasma-umass/DataDebug
        // Count instances of unique string output values and return multinomial probability vector
        public static Dictionary<string, double> BootstrapFrequency(IEnumerable<FunctionOutput<string>> boots)
        {
            var counts = new Dictionary<string, int>();

            foreach (FunctionOutput<string> boot in boots)
            {
                string key = boot.GetValue();
                int count;
                if (counts.TryGetValue(key, out count))
                {
                    counts[key] = count + 1;
                }
                else
                {
                    counts.Add(key, 1);
                }
            }

            var p_values = new Dictionary<string,double>();

            var bootcount = (double)boots.Count();
            foreach (KeyValuePair<string,int> pair in counts)
            {
                p_values.Add(pair.Key, (double)pair.Value / bootcount);
            }

            return p_values;
        }
コード例 #27
0
        public string writeXML(string rootElement, Dictionary<string, object> keyValueDictionary)
        {
            try
            {
                StringWriter stringWriter = new StringWriter();
                XmlTextWriter xmlWriter = new XmlTextWriter(stringWriter);
                //xmlWriter.Formatting = Formatting.Indented;
                //xmlWriter.Indentation = indentation;

                // write root element
                xmlWriter.WriteStartElement(rootElement);
                xmlWriter.WriteAttributeString("xmlns", "ns", null, "http://ilab.mit.edu/iLab");

                foreach (string s in keyValueDictionary.Keys)
                {
                    xmlWriter.WriteStartElement(s);
                    object value = new object();
                    keyValueDictionary.TryGetValue(s, out value);
                    xmlWriter.WriteString(value.ToString());
                    xmlWriter.WriteEndElement();
                }

                xmlWriter.WriteEndElement();
                return stringWriter.ToString();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                Console.WriteLine(e.StackTrace);
            }

            return null;
        }
コード例 #28
0
        private object GetModel(Dictionary<string, object> scopeArgs)
        {
            object model;
            if (!scopeArgs.TryGetValue(this.MemberVarName, out model))
                throw new ArgumentException(this.MemberVarName + " does not exist");

            return model;
        }
コード例 #29
0
ファイル: ReadArticles.cs プロジェクト: satishinext/php
		/*	void DisplayArticles()
			{
				for(int i=1; i<2; i++)
				{
					GameObject gObj = Instantiate(ArticleTemplate,Vector3.zero,Quaternion.identity) as GameObject;
					gObj.transform.parent = this.transform;
					gObj.transform.localPosition = new Vector3(0,-500 *i, 0);
				}		
			}*/
		private string getDataValueForKey(Dictionary<string, object> dict, string key) {
			object objectForKey;
			if (dict.TryGetValue(key, out objectForKey)) {
				return (string)objectForKey;
			} else {
				return "";
			}
		}
コード例 #30
0
ファイル: WorkItemFetcher.cs プロジェクト: ArildF/Smeedee
        public WorkItemFetcher(String serverAddress, String projectName, ICredentials credentials,
                               Dictionary<String, String> configuration)
        {
            String configValue = "";
            WORK_REMAINING_FIELD = (configuration.TryGetValue("tfswi-remaining-field", out configValue))
                                       ? configValue
                                       : WORK_REMAINING_FIELD;
            ESTIMATED_EFFORT_FIELD = (configuration.TryGetValue("tfswi-estimated-field", out configValue))
                                         ? configValue
                                         : ESTIMATED_EFFORT_FIELD;

            this.projectName = projectName;

            tfsServer = new TeamFoundationServer(serverAddress, credentials);
            tfsServer.Authenticate();

            workItemStore = tfsServer.GetService(typeof (WorkItemStore)) as WorkItemStore;
        }