We Keep Coding

How to activate 2 gameobjects randomly?

I have this code but looks like the random is activating the same gameobject. How can I be sure that not the same will be activated? For example, this code activate 2 gameobjects but sometimes just only one, because the random picked the same gameobjects twice.
for (int i = 0; i < 2; i++)
{
int index = Random.Range(0, EyeButtonArray.Length);
EyeButtonArray[index].SetActive(true);
}

You can shuffle your container randomly and pick the first two elements.
int wanted = 2;
int[] nums = System.Linq.Enumerable.Range(0, EyeButtonArray.Length).ToArray();
System.Random rnd = new System.Random();
nums = nums.OrderBy(x => rnd.Next()).ToArray();
for(int x = 0; x < 2; ++x)
EyeButtonArray[nums[x]].SetActive(true);
Another solution using a HashSet is to keep track of the elements you have picked and keep generating until you pick a unique one.
HashSet<int> RandomElementIdx = new HashSet<int>();
int picked = 0;
int wanted = 2;
while(picked < wanted)
{
int index = Random.Range(0, EyeButtonArray.Length);
if(RandomElementIdx.Contains(index))
continue;
RandomElementIdx.Add(index);
EyeButtonArray[index].SetActive(true);
++picked;
}
The above snippet is assuming your list is greater than or equal to wanted. If it is less, it will result in an infinite loop. It is also not exactly efficient as it will continually try to spawn new numbers until it randomly hits one not used.

It sounds like what you want is
You have a list/array of objects
You want to enable the next two random ones of them
(optionally - not sure on this) you want to disable the two current ones
You could simply "shuffle" your array and then enable the two first of the now shuffled items like e.g.
using System.Linq;
...
// OPTIONAL (but I thought makes sense)
// store the currently enabled objects to also be able to disable them later
// when you enable the next pair
private GameObject[] _currentEnabled;
public void EnableTwoRandom()
{
// OPTIONAL (but I thought makes sense)
// if exists first disable the last selected two buttons
if(_currentEnabled!=null)
{
foreach(var item in _currentEnabled)
{
item.SetActive(false);
}
}
// Pick two random buttons
// This first "shuffles" the buttons and then simply takes the
// first two random elements
_currentEnabled = EyeButtonArray.OrderBy(i => Random.value).Take(2).ToArray();
// enable the new two random buttons
foreach(var item in toEnable)
{
item.SetActive(true);
}
}
See
IEnumerable.OrderBy
Random.value
IEnumerable.Take
if additionally you want to be sure that the new selected buttons are also not equal to the previous ones you could add
// Pick two random buttons
if(_currentEnabled != null)
{
// if there already exists a previous selection
// then exclude this selection from the available options first
_currentEnabled = EyeButtonArray.Except(_currentEnabled).OrderBy(i => Random.value).Take(2).ToArray();
}
else
{
_currentEnabled = EyeButtonArray.OrderBy(i => Random.value).Take(2).ToArray();
}
See
IEnumerable.Except

Array data has unexpected data every other frame

Console log
My list is adding the sprite name and converting it to an integer to add to a list, then I created a function to show the list but whenever I show the list in the update loop, it alternates between showing just 0's
and actual values. and when I don't put it in an update loop it only shows 0's
public class ballMove : MonoBehaviour {
int[] BallOrder = new int[5]; // me initializing the variable in the
beginning of the program
// int[] BallOrder = {4,6,3,2,7}; if I do this instead of showing 0's it
shows 4,6,3,2,7 when I click the mouse down.
void CreateBalls(int HowMany) {
// makes balls with a unique picture size and position
for (int i = 0; i < HowMany; i++) {
BallClone = Instantiate(Ball);
BallPic = BallClone.GetComponent<SpriteRenderer>();
// give each ball a random image, each image is a number
RandImg();
// just using i for testing purposes.
BallOrder[i] = i;
//array should just be 1,2,3,4,5
}
}
void ShowList()
{
System.Array.Sort(BallOrder);
string text = "";
for (int i = 0; i < BallOrder.Length; i++)
{
text = (text + " " + BallOrder[i]);
}
print(text);
}
void Update()
{
// here it shows the array correctly 1,2,3,4,5
ShowList();
}
void OnMouseDown() {
string BallNum = ConvertSprite(GetComponent<SpriteRenderer>().sprite);
int test = int.Parse(BallNum);
ShowList(); // here when I show list it just shows 0,0,0,0,0
Destroy(gameObject);
}
}

Just to give an answer to the question that is not in comments, the issue was that the console was printing out what could be considered bad data.
By alternating between what was expected (6 random numbers) and not expected (6 zeroes), clearly, the function was being called twice, but from further additions of code snippets, there was no reason as to why the function would be called multiple times.
From the initialization of the array data, the only way for there to be 6 zeroes instead of data was that the data was being overwritten or that it was never initialized. As the array is never written to again after the initialization, it must have meant that it was initialized incorrectly.
The only way for this to have occurred is by having the script attached to two objects in the scene where one is properly initializing the data and the other is not as the initialization occurred in Start.
The solution is to remove the unused script from one of the two objects in the scene.

How to iterate backwards (with pauses for input) through a set of randomly generated numbers?

// EDIT:
This is not a duplicate to: "When should I use a List vs a LinkedList". Check the answer I've provided below.
LinkedList might be useful though if someone wants to insert some positions at a specific place after we have a properly ordered List (in that case - LinkedList) already - how to make one, check my answer below. //
How would you iterate backwards (with pauses for player input) through a set of randomly generated numbers?
I'm trying to build a turn-based game. The order of actions is determined by a result of something like that:
int randomPosition = Random.Range(1,31) + someModifier;
// please note that someModifier can be a negative number!
// There is no foreseeable min or max someModifier.
// Let's assume we can't set limits.
I have a List of KeyValue pairs already containing names of objects and their corresponding randomPosition. // Update: Values of it are already sorted by a custom Sort() function, from highest to lowest.
// A list of KeyValue pairs containing names of objects and their corresponding randomPosition.
public List<KeyValuePair<string, int>> turnOrder = new List<KeyValuePair<string, int>> ();
// GameObject names are taken from a list of player and AI GameObjects.
List <GameObject> listOfCombatants = new List<GameObjects>();
// Each GameObject name is taken from listOfCombatants list.
listOfCombatants[i].name;
I thought, maybe let's add player and AI GameObjects to a list on Index positions equal to each of their randomPosition. Unfortunately, a Generic List can't have "gaps" in it. So we can't create it, let alone iterate it backwards.
Also, I'm not sure how we'd stop a for loop to wait for player input. I have a button, pressing which will perfom an action - switch state and run some functions.
Button combat_action_button;
combat_action_button.onClick.AddListener (AttackButton);
// When player takes his turn, so in TurnState.PLAYER_ACTION:
public void AttackButton() {
switch(actionState) {
case PlayerAction.ATTACK:
Debug.Log (actionState);
// Do something here - run function, etc. Then...
currentState = TurnState.ENEMY_ACTION;
break;
}
To make things worse, I've read that "pausing" a while loop isn't good for performance. That it's better to take player input out of loops.
So maybe I should create more for loops, iterate a new loop from position to position until the last GameObject acted, and use some delegates/events, as some things players/AI can do are in different scripts (classes).
This is not a real-time project, so we can't base anything on time (other than potential max turn time).
Another thing is, we don't know how many GameObjects will take turns.
But maybe there's some collection type that can store GameObjects with gaps between their index positions and iterate a loop from highest to lowest with no problem?...
I want to make it as simple as possible.

For the issue of simultaneously having user input and looping, I recommend looking into background workers or threading/tasks. This should facilitate your problem with simultaneously doing two things at once.
For your list problem I personally prefer the lists as well which is why I would designate each "gap" with a specific character like - 1, and when referencing the data ignore the - 1. To ignore the gaps I recommend LINQ queries but if you don't want to use LINQ that should not be a problem.
EDIT*
I know very little about Unity but from what people have been saying it sounds like running multiple threads is or can be an issue. I looked into this issue and it sounds like you just cannot call the unity api from a background thread. So basically, as long as you do not reference the unity api from the background thread, you should be ok. With that said, you may possibly need/want to make a call to the api inside of the background worker. To do this you need to either invoke the call before or after the background worker thread. I am pretty sure there is also a simultaneous invocation from the main thread by setting the workers step property to true.

I've decided to share my own solutions as I think I've developped some accurate answers to my questions.
Solution #1. First, declare an array, 2 variables and 1 function:
int[] arrayOrderedCombatants;
int min = 100000;
int max;
public void SomePlayerAction() {
Debug.Log ("This is some player or AI action.");
}
public void IterateThroughTurnOrderPositions() {
for (int i=max; i >= min; i--) {
if (arrayOrderedCombatants [i] >= 0 && arrayOrderedCombatants [i] >= min) {
Debug.Log ("This is an existing position in turn order: " + arrayOrderedCombatants [i]);
foreach (var position in turnOrder) {
if (position.Value == arrayOrderedCombatants [i]) {
max = (arrayOrderedCombatants [i] - 1);
goto ExitLoop;
}
}
}
}
ExitLoop:
SomePlayerAction ();
}
Then, for our testing purposes let's use an Update() method triggered by Input.GetKeyDown:
if (Input.GetKeyDown (KeyCode.O)) {
arrayOrderedCombatants = new int[turnOrder[0].Value + 1];
Debug.Log ("This is arrayOrderedCombatants Length: " + arrayOrderedCombatants.Length);
foreach (var number in turnOrder) {
if (number.Value < min)
min = number.Value;
}
Debug.Log ("This is min result in random combat order: " + min);
for (int i=0; i < arrayOrderedCombatants.Length; i++)
arrayOrderedCombatants[i] = min -1;
foreach (var combatant in turnOrder) {
if (combatant.Value >= 0) {
arrayOrderedCombatants [combatant.Value] = combatant.Value;
}
}
max = turnOrder [0].Value;
while (max >= min)
IterateThroughTurnOrderPositions ();
}
The above code answers my question. Unfortunately, problems with this solution may be two. First - you can't have a negative index position. So if someModifier makes randomPosition go below 0, it won't work. Second problem - if you have more than 1 occurance of any value from randomPosition, it will be added to the arrayOrderedCombatants only once. So it will be iterated once too.
But that's obvious - you can't have more than one value occupying an int type Arrays' index position.
So I will provide you a better solution. It's a different approach, but works like it should.
Solution #2. First, declare a list of GameObjects:
List<GameObject> orderedCombatants = new List<GameObject> ();
Then, in Update() method:
if (Input.GetKeyDown (KeyCode.I)) {
orderedCombatants.Clear ();
foreach (var combatant in initiative) {
Debug.Log (combatant);
for (int i=0; i < listOfCombatants.Count; i++) {
if (listOfCombatants[i].name.Contains(combatant.Key)) {
orderedCombatants.Add(listOfCombatants[i]);
}
}
}
foreach (var combatant in orderedCombatants) {
Debug.Log (combatant.name);
}
}
The above creates a new list of GameObjects already set in the right order. Now you can iterate through it, easily access each GameObject and perform any actions you need.

c# shift the elements of array by 1 with for loop

Im making a game in c# and it have a scoreboard with the top 5 players.
I made it to work, at least I thought I did...
The script enter the value of player's name and his score in a array, but there is a problem. It just delete the last one, so if you make the best score you become #1, but the old #1 is deleted and #2 is always #2 unless someone make a result for that place. My question is how to move the array by one from some place (it depends on player's result) and delete the last string of it?
Edit: Can't use list, because im doing so much stuff with that array.
Like this:
string topScores = sbName[i].Substring(4);
int topScoreInt = Convert.ToInt32(topScores);

If you need to use an array instead of a List (which has a handy Insert method), you could work your way from the last value forward, replacing each with it's predecessor's value, until you get to the one you want to update:
int place = 2; // Meaning 3rd place, since arrays are zero-based
// Start at end of array, and replace each value with the one before it
for (int i = array.Length - 1; i > place; i--)
{
array[i] = array[i - 1];
}
// Update the current place with the new score
array[place] = score;

Since you have just 5 items and scoring is normally rare some basic LINQ code would be easier and likely more readable:
class Score { public string Name; public int Result;}
Score[] scores = new Score[5];
var newScore = new Score {Name = "Foof", Result=9001};
scores = scores
.Where(s => s != null) // ignore empty
.Concat(Enumerable.Repeat(newScore,1)) // add new one
.OrderByDescending(s => s.Result) // re-sort
.Concat(Enumerable.Repeat((Score)null,4)) // pad with empty if needed
.Take(5) // take top X
.ToArray(); // back to array
Side note: You really will be better off using List<T> or SortedList<K,V>.

A List of Lists containing int and string, need to output X strings with highest int values based on TrackBar (not a sorted list)

I have a List structured as:
"Then a sentence woop", 340
"and another one", 256
"in order they appear", 700
"in a linked file", 304
The list contains the highest scored sentence from each paragraph of a text file. I need to output each sentence, but with a track bar reduce how many are shown.
So remove the sentence with the lowest score, the issue is the list is ordered by the sentences appearance in the original text, and the output needs to be in this order. So if I had a track bar for the above list, it would have 4 points. If I move it to point 3 sentence 2 would vanish, point 2 sentence 2 and 4 would vanish.
The code where the list is generated is:
public List<ScoredSentence> buildSummarySentenceList()
{
List<ScoredSentence> ultimateScoreslist = new List<ScoredSentence>();
scoreCoord2 = -1;
for (int x1 = 0; x1 < results.Length; x1++)
{
List<ScoredSentence> paragraphsScorelist = new List<ScoredSentence>();
for (int x2 = 0; x2 < results[x1].Length; x2++)
{
scoreCoord2++;
paragraphsScorelist.Add(new ScoredSentence(results[x1][x2], intersectionSentenceScores[scoreCoord2]));
}
var maxValue = paragraphsScorelist.Max(s => s.score);
string topSentence = paragraphsScorelist.First(s => s.score == maxValue).sentence;
int topScore = paragraphsScorelist.First(s => s.score == maxValue).score;
ultimateScoreslist.Add(new ScoredSentence(topSentence, topScore));
}
return ultimateScoreslist;
}
public class ScoredSentence
{
public string sentence { get; set; }
public int score { get; set; }
public ScoredSentence(string sentence, int score)
{
this.sentence = sentence;
this.score = score;
}
}
This code loops though a jagged array and a list of sentence to sentence scores, it results in a list as shown at the top.
Currently I output every sentence, and set the trackbar to be as long as there are sentences:
protected void summaryOutput()
{
List<ScoredSentence> ultimateScoreslist = buildSummarySentenceList();
trackBSummaryPercent.Maximum = ultimateScoreslist.Count;
lblNoOfLines.Text += trackBSummaryPercent.Maximum.ToString();
//make 2 lists for the reduction????
for (var x = 0; x < ultimateScoreslist.Count; x++)
{
TextboxSummary.Text += ultimateScoreslist[x].sentence + "\n";
}
}
I have thought of on every onchange tick of the trackbar to have a second clone list and remove the lowest value entry. Then when the bar is moved up to somehow move the missing entries back from the clone list. I don't like this method as it may cause program speed issues when for example my current test text is 100 paragraphs long, and moving the trackbar a lot may make it become slow.

Add a displayed property to your ScoredSentence object. Then whenever the list changes, or the track bar selection changes, run this method on it to update the set of displayed elements. The main list should always be sorted in the order you want it displayed. numberToDisplay would be calculated by whatever means you are using to go from your UI to the number of items.
public void OnUpdate()
{
var orderedEnumerable = ScoresList.OrderByDescending (s => s.Score);
foreach (var s in orderedEnumerable.Take (numberToDisplay))
{
s.Displayed = true;
}
foreach (var s in orderedEnumerable.Skip(numberToDisplay))
{
s.Displayed = false;
}
}
Then use the following instead of the list whenever you need to display it
ScoredSentences.Where(s=> s.Displayed);