public Sprites(Texture2D TextureIn, Rectangle RectangleIn)
{
SpriteTexture = TextureIn;
SpriteRectangle = RectangleIn;
SpriteType = SpriteTypes.Sprite;
SpriteColour = Color.White;
}
internal pSprite(Texture2D texture, FieldTypes fieldType, OriginTypes originType, ClockTypes clockType,
Vector2 startPosition, float drawDepth, bool alwaysDraw, Color colour, Object tag)
{
Type = SpriteTypes.Image;
localTexture = texture;
Disposable = false;
SpriteEffect = SpriteEffects.None;
OriginType = originType;
UpdateTextureSize();
UpdateTextureAlignment();
Clock = clockType;
CurrentPosition = startPosition;
StartPosition = CurrentPosition;
CurrentRotation = 0;
CurrentScale = 1;
Depth = drawDepth;
AlwaysDraw = alwaysDraw;
Field = fieldType;
CurrentColour = colour;
StartColour = colour;
Tag = tag;
}
public InformationNugget(string infoText, DisplayStatus nextDisplayStatus, int displayTime, bool skippable, SpriteTypes type = SpriteTypes.None)
{
InfoText = infoText;
NextDisplayStatus = nextDisplayStatus;
DisplayTime = displayTime;
Skippable = skippable;
Type = type;
}
private Dictionary <SpriteTypes, int> GetCellSpriteTyes(int maxCount, int noofAvaialbleSprites, ref List <SpriteTypes> cellSpriteTypesList) // returns sprite types for cells
{
HashSet <int> availableSpritesHash = new HashSet <int>();
for (int i = 0; i < noofAvaialbleSprites; i++)
{
availableSpritesHash.Add(i);
}
Dictionary <SpriteTypes, int> spriteTypes = new Dictionary <SpriteTypes, int>(); //TODO : introduce duplciates
for (int i = 0; i < maxCount; i++)
{
int randomRange = 0;
if (availableSpritesHash.Count > 0) // maxCount < number of availabe
{
randomRange = UnityEngine.Random.Range(0, availableSpritesHash.Count);
}
else
{
randomRange = UnityEngine.Random.Range(0, noofAvaialbleSprites); // creats duplicate values
SpriteTypes spriteType = (SpriteTypes)randomRange;
if (spriteTypes.ContainsKey(spriteType))
{
spriteTypes[spriteType] = spriteTypes[spriteType] + 2;
}
else
{
cellSpriteTypesList.Add((SpriteTypes)randomRange);
spriteTypes.Add((SpriteTypes)randomRange, 2);
}
continue; // continue to next iteration
}
int j = 0;
int randomSprite = 0;
foreach (int hashValue in availableSpritesHash) // might need to re write
{
if (j == randomRange)
{
randomSprite = hashValue;
break;
}
j++;
}
cellSpriteTypesList.Add((SpriteTypes)randomSprite);
spriteTypes.Add((SpriteTypes)randomSprite, 2); // two here represents number of pairs
availableSpritesHash.Remove(randomSprite);
}
return(spriteTypes);
}
public ISpriteTime GetTimeSettings(SpriteTypes type)
{
ISpriteTime desired;
switch (type)
{
case SpriteTypes.Correct:
desired = CorrectSpriteSettings;
break;
case SpriteTypes.Incorrect:
desired = IncorrectSpriteSettings;
break;
case SpriteTypes.Baseline:
desired = BaselineSpriteSettings;
break;
case SpriteTypes.Target:
desired = TargetSpriteSettings;
break;
case SpriteTypes.ControlCue:
desired = ControlCueSpriteSettings;
break;
case SpriteTypes.ControlNonIncentive:
desired = ControlNonincentiveSpriteSettings;
break;
case SpriteTypes.RewardCue:
desired = RewardCueSpriteSettings;
break;
case SpriteTypes.RewardNonIncentive:
desired = RewardNonIncentiveSpriteSettings;
break;
case SpriteTypes.PunishmentCue:
desired = PunishmentCueSpriteSettings;
break;
case SpriteTypes.PunishmentNonIncentive:
desired = PunishmentNonIncentiveSpriteSettings;
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
return(desired);
}
private void InitValues()
{
_taskType = Randomness.RandomizeField(_taskSettings.NumberOfTasks, _taskSettings.NonIncentivePercentage);
_upcomingSpriteType = _taskType[0] == 0 ? _taskSettings.NonIncentiveOrder[0] : _taskSettings.IncentiveOrder[0];
_reactionTimes = new double[_taskSettings.NumberOfTasks];
for (var i = 0; i < _taskSettings.NumberOfTasks; i++)
{
_reactionTimes[i] = -1;
}
_iSprite = -1;
_passedTime = 0;
_numberOfSpamming = 0;
AntiSpamming.Clear();
}
private Dictionary <SpriteTypes, Sprite> spriteMap; // cahe map for 0(1) retrivel
void Awake()
{
spriteMap = new Dictionary <SpriteTypes, Sprite>();
for (int i = 0; i < sprites.Length; i++)
{
string spriteName = sprites[i].name;
SpriteTypes spriteType = (SpriteTypes)Enum.Parse(typeof(SpriteTypes), spriteName);
if (!spriteMap.ContainsKey(spriteType))
{
spriteMap.Add(spriteType, sprites[i]);
}
else
{
Debug.Log("some files got similar name");
}
}
}
/// <summary>
/// Change of Sprite intervals
/// </summary>
/// <param name="spriteType"></param>
/// <param name="type"></param>
/// <param name="newValue"></param>
public Change(SpriteTypes spriteType, SettingsType type, int newValue)
{
switch (type)
{
case SettingsType.WaitIntervalMin:
case SettingsType.WaitIntervalMax:
case SettingsType.DisplayIntervalMin:
case SettingsType.DisplayIntervalMax:
IsSprite = true;
SpriteType = spriteType;
SettingsType = type;
NewValue = newValue;
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, "Not applicable type");
}
}
private void HandleUserInput()
{
RemoveNotification();
bool isIncentive = _taskType[(_iSprite - 1) / 3] != 0;
if (!_spacebarPressed || _iSprite < 1)
{
return;
}
CheckSpamming();
if (_iSprite < 1 || !(_reactionTimes[(_iSprite - 1) / 3] < 0))
{
return;
}
SpriteTypes type = SpriteTypes.Correct;
_reactionTimes[(_iSprite - 1) / 3] = _passedTime;
if (_passedTime > _threshold)
{
type = SpriteTypes.Incorrect;
}
if (!isIncentive)
{
_taskSettings.NonIncentiveOrder[2] = type;
SendFeedback(_passedTime, false);
}
else
{
_taskSettings.IncentiveOrder[2] = type;
SendFeedback(_passedTime, true);
}
}
private void ShowSprite()
{
_iSprite++;
if (_iSprite % 3 == 2 && _reactionTimes[_iSprite / 3] < 0)
{
if (_taskType[_iSprite / 3] == 0)
{
_taskSettings.NonIncentiveOrder[_iSprite % 3] = SpriteTypes.Incorrect;
}
else
{
_taskSettings.IncentiveOrder[_iSprite % 3] = SpriteTypes.Incorrect;
}
}
_currentSpriteType = _taskType[_iSprite / 3] == 0 ? _taskSettings.NonIncentiveOrder[_iSprite % 3] : _taskSettings.IncentiveOrder[_iSprite % 3];
if (_iSprite < _taskSettings.NumberOfTasks * 3 - 1)
{
_upcomingSpriteType = _taskType[(_iSprite + 1) / 3] == 0 ? _taskSettings.NonIncentiveOrder[(_iSprite + 1) % 3] : _taskSettings.IncentiveOrder[(_iSprite + 1) % 3];
}
_currentSprite = SpriteHandler.Sh.CreateSprite(_currentSpriteType, _panel);
_currentDisplayStatus = DisplayStatus.DisplayingSprite;
}
public void SetSpriteType(SpriteTypes newType)
{
Type = newType;
}
public Sprite(SpriteTypes spritetype)
{
SpriteType = spritetype;
}
public LevelSession GetLevelSession(int levelIndex, Vector3 levelCenterPostion)
{
LevelParserData levelParserData = LevelParser.LoadLevelData(levels[levelIndex].levelFileName);
int rows = levelParserData.rows;
int columns = levelParserData.columns;
int totlaNumberOFX = levelParserData.filledCellCount; // number of filled blocks
if (totlaNumberOFX % 2 != 0)
{
Debug.LogError("levele contains even tiles"); // we expect all even filled blocks
Debug.Break();
}
List <Vector2> filledCellIndexList = new List <Vector2>();
for (int i = 0; i < rows; i++)
{
List <bool> currentRow = levelParserData.levelInfoList[i];
for (int j = 0; j < currentRow.Count; j++)
{
if (currentRow[j] == true)
{
filledCellIndexList.Add(new Vector2(i, j));
}
}
}
int numberOfTileSNeeded = totlaNumberOFX / 2;
int noofAvaialbleSprites = Enum.GetNames(typeof(SpriteTypes)).Length;
int numberOfCloseByExpected = UnityEngine.Random.Range(2, 4); // expected close by pairs
Dictionary <SpriteTypes, int> cellSpriteTypesDict = new Dictionary <SpriteTypes, int>(); // dictionary will track the count of used ons
List <SpriteTypes> cellSpriteTypesList = new List <SpriteTypes>(); // list as key for dictionary
cellSpriteTypesDict = GetCellSpriteTyes(numberOfTileSNeeded, noofAvaialbleSprites, ref cellSpriteTypesList); // type of sprite that we are gonna show it on the screnn
// we create grid with one extra 2 row and 2 column. this helps to find the outer path beyond the grid dimentions
// session cell starts at (1,1) and end at ( row -1, column-1)
Grid2D grid2D = new Grid2D(rows + 2, columns + 2, 1.0f, 1.0f, levelCenterPostion); // ading extra column and row
Dictionary <SpriteTypes, List <Cell> > connectionMap = new Dictionary <SpriteTypes, List <Cell> >();
//TODO: close by pairs
for (int i = 0; i < filledCellIndexList.Count; i++)
{
Vector2 currentIndex = filledCellIndexList[i];
Vector2 cellIndex = new Vector2(currentIndex.x + 1, currentIndex.y + 1);
Cell cell = grid2D.Cells[(int)cellIndex.x, (int)cellIndex.y];
cell.CellPositionIndex = cellIndex;
int randomSpriteNo = UnityEngine.Random.Range(0, cellSpriteTypesList.Count);
SpriteTypes randomSprite = cellSpriteTypesList[randomSpriteNo];
if (cellSpriteTypesDict.ContainsKey(randomSprite)) // we expecting the diction contins the key
{
cellSpriteTypesDict[randomSprite] -= 1;
if (cellSpriteTypesDict[randomSprite] == 0)
{
cellSpriteTypesList.Remove(randomSprite);
cellSpriteTypesDict.Remove(randomSprite);
}
}
SpriteObject spriteObject = new SpriteObject(randomSprite);
cell.CellObj = spriteObject;
spriteObject.ParentCell = cell;
if (connectionMap.ContainsKey(randomSprite))
{
connectionMap[randomSprite].Add(cell);
}
else
{
connectionMap.Add(randomSprite, new List <Cell>()
{
cell
});
}
float randomeValue = UnityEngine.Random.value;
}
_currentLevelGrid = grid2D;
LevelSession levelSession = new LevelSession(grid2D, connectionMap);
levelSession.RemainigSpritObjCnt = totlaNumberOFX; // init max sprite count
levelSession.SpriteObjCount = totlaNumberOFX;
return(levelSession);
}
public SpriteTime(Interval waitInterval, Interval displayInterval, SpriteTypes type)
{
DisplayInterval = displayInterval;
WaitInterval = waitInterval;
Type = type;
}
public static void SetSpriteField(SpriteTypes spriteType, SettingsType type, int newValue)
{
Changes.Add(new Change(spriteType, type, newValue));
}
public GameObject CreateSprite(SpriteTypes spriteType, GameObject panel, Position position = Position.Middle)
{
var newObj = new GameObject();
var newImage = newObj.AddComponent <Image>();
switch (spriteType)
{
case SpriteTypes.Baseline:
newImage.sprite = BaselineSprite;
break;
case SpriteTypes.Target:
newImage.sprite = TargetSprite;
break;
case SpriteTypes.ControlCue:
newImage.sprite = ControlCueSprite;
break;
case SpriteTypes.ControlNonIncentive:
newImage.sprite = ControlNonIncentiveSprite;
break;
case SpriteTypes.RewardCue:
newImage.sprite = RewardCueSprite;
break;
case SpriteTypes.PunishmentCue:
newImage.sprite = PunishmentCueSprite;
break;
case SpriteTypes.RewardNonIncentive:
newImage.sprite = RewardNonIncentiveSprite;
break;
case SpriteTypes.PunishmentNonIncentive:
newImage.sprite = PunishmentNonIncentiveSprite;
break;
case SpriteTypes.Correct:
newImage.sprite = CorrectSprite;
break;
case SpriteTypes.Incorrect:
newImage.sprite = IncorrectSprite;
break;
default:
throw new ArgumentOutOfRangeException(nameof(spriteType), spriteType, null);
}
newObj.GetComponent <RectTransform>().SetParent(panel.transform);
switch (position)
{
case Position.Middle:
newObj.transform.localPosition = new Vector3(0, 0);
break;
case Position.Above:
newObj.transform.localPosition = new Vector3(0, 200);
break;
case Position.Below:
newObj.transform.localPosition = new Vector3(0, -200);
break;
default:
throw new ArgumentOutOfRangeException(nameof(position), position, null);
}
newObj.SetActive(true);
return(newObj);
}
