public static void ChangeRooms(int xOffset, int yOffset, PlayerMarker playerMarker)
{
Room destination = playerMarker.matrix.RoomAt(playerMarker.xPosition + xOffset, playerMarker.yPosition + yOffset);
if (destination != null)
{
Room origin = playerMarker.matrix.RoomAt(playerMarker.xPosition, playerMarker.yPosition);
if (origin.DoorAt(xOffset, yOffset) || destination.DoorAt(xOffset * -1, yOffset * -1))
{
GameObject room = playerMarker.matrix.ElementAtArrayPosition(playerMarker.xPosition + xOffset, playerMarker.yPosition + yOffset);
playerMarker.transform.position = room.transform.position;
playerMarker.matrix.grid.AlignTransform(playerMarker.transform);
playerMarker.xPosition += xOffset;
playerMarker.yPosition += yOffset;
origin.ExitRoom();
destination.EnterRoom();
if (destination.messages.Length > 0)
{
SpeechBubble.mainBubble.Activate();
SpeechBubble.mainBubble.textToDisplay = destination.messages;
}
if (destination.enemies.Count > 0)
{
GameController.EnterEncounter(destination);
}
activeRoom = destination;
UIController.instance.Reset();
UpdateNav(destination);
}
}
}
private void Awake()
{
_health = GetComponent <Health>();
_player = FindObjectOfType <PlayerMarker>();
_follower = GetComponent <Follower>();
_follower.target = _player.transform;
}
private void CenterCameraOnPlayer()
{
PlayerMarker player = FindObjectOfType <PlayerMarker>();
Vector3 newCameraPosition = new Vector3(player.transform.position.x, player.transform.position.y, Camera.main.transform.position.z);
Camera.main.transform.position = newCameraPosition;
}
public AnimationService(MovementEventRepository movementEventRepository,
SkeletonAnimation skeletonAnimation, PlayerMarker player)
{
this.movementEventRepository = movementEventRepository ?? throw new ArgumentNullException(nameof(movementEventRepository));
this.skeletonAnimation = skeletonAnimation ?? throw new ArgumentNullException(nameof(skeletonAnimation));
this.idle = player.idle ?? throw new ArgumentNullException(nameof(idle));
this.walking = player.walking ?? throw new ArgumentNullException(nameof(walking));
this.player = player ?? throw new ArgumentNullException(nameof(player));
}
private void Awake()
{
_playerMarker = FindObjectOfType <PlayerMarker>();
_virtualCameraCOnfinerMarker = FindObjectOfType <VirtualCameraConfinerMarker>();
_cinemachineVirtualCamera = GetComponent <CinemachineVirtualCamera>();
_cinemachineConfiner = GetComponent <CinemachineConfiner>();
_cinemachineVirtualCamera.m_Follow = _playerMarker?.transform;
_cinemachineConfiner.m_BoundingShape2D = _virtualCameraCOnfinerMarker?.GetComponent <PolygonCollider2D>();
}
/**
* Initialize all references needed and activate the circle marker if we own this player instance
*/
void Awake()
{
if (photonView.owner == PhotonNetwork.player)
{
mover = GetComponent <CharacterMover>();
markerInstance = ((GameObject)Instantiate(marker)).GetComponent <PlayerMarker>();
circleMarker.SetActive(true);
}
match = GameObject.Find("PhotonNetman").GetComponent <Match>();
}
//Swap attached players between two markers
public void Swap( PlayerMarker p)
{
//swap player links between two markers
FPlayer TempSlot;
TempSlot = this.LinkedPlayer;
this.LinkedPlayer = p.LinkedPlayer;
p.LinkedPlayer = TempSlot;
//!!!need to update jerseys
}
public void MovePlayer(MapSquare currentSquare, MapSquare targetSquare)
{
PlayerMarker playerMarker = FindObjectOfType <PlayerMarker>();
playerMarker.SetTargetPosition(targetSquare.GetPlayerMarkerPosition());
playerMarker.moveTowardTargetPosition();
playerMarker.SetCurrentSquare(targetSquare);
currentSquare.UnsetPlayerPosition();
targetSquare.SetPlayerPosition();
}
public void InitRegionInfo()
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
//IL_0127: Unknown result type (might be due to invalid IL or missing references)
//IL_0153: Unknown result type (might be due to invalid IL or missing references)
//IL_0158: Expected O, but got Unknown
//IL_0164: Unknown result type (might be due to invalid IL or missing references)
//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
if (spots != null)
{
Transform val = spots.SetRoot(base._transform);
if (uiMapSprite == null)
{
uiMapSprite = val.FindChild("Map").get_gameObject().GetComponent <UITexture>();
}
InitMapSprite(MonoBehaviourSingleton <ScreenOrientationManager> .I.isPortrait);
worldMapObject.get_gameObject().SetActive(true);
for (int i = 0; i < openedRegionInfo.Length; i++)
{
RegionTable.Data data = openedRegionInfo[i].data;
if (data != null)
{
SpotManager.Spot spot = spots.AddSpot((int)data.regionId, data.regionName, data.iconPos, SpotManager.ICON_TYPE.CLEARED, "OPEN_REGION", false, false, false, null, null, false, SpotManager.HAPPEN_CONDITION.NONE, 0);
spot.SetIconSprite("SPR_ICON", openedRegionInfo[i].icon.loadedObject as Texture2D, (int)data.iconSize.x, (int)data.iconSize.y);
if (fromRegionID == data.regionId)
{
playerMarker.get_gameObject().SetActive(true);
playerMarker.SetParent(worldMapObject.get_transform());
PlayerMarker component = playerMarker.GetComponent <PlayerMarker>();
component.SetWorldMode(true);
component.SetCamera(worldMapCamera._camera.get_transform());
playerMarker.set_localPosition(data.markerPos);
}
if (toRegionID == data.regionId)
{
targetRegionIcon = spot._transform;
if (!eventData.IsOnlyCameraMoveEvent())
{
spot._transform.get_gameObject().SetActive(false);
}
else
{
spot._transform.get_gameObject().SetActive(true);
}
}
}
}
}
}
// ustawienia domyślne w konstruktorze
public Settings()
{
ButtonWidth = 64;
ButtonHeight = 64;
BoardSize = 3;
CurrentPlayer = PlayerMarker.X;
CurrentGameMode = GameMode.PlayerVsPlayer;
GameOver = false;
WonPlayer = PlayerMarker.Empty;
}
// sprawdź w rzędzie pionowo, konkretnie sprawdz pola na wsp. y dla zadanego x
bool CheckWinningPatternVertical(int startX, PlayerMarker player)
{
for (int y = 0; y < Settings.BoardSize; ++y)
{
int index = (y * Settings.BoardSize) + startX;
if (buttons[index].Text != player.ToString())
{
return(false);
}
}
return(true);
}
// sprawdź w rzędzie poziomo, konkretnie sprawdź pola na wsp. x dla zadanego y
bool CheckWinningPatternHorizontal(int startY, PlayerMarker player)
{
for (int x = 0; x < Settings.BoardSize; ++x)
{
int index = (startY * Settings.BoardSize) + x; // policz który to indeks w liście przycisków
// jeżeli którykolwiek będzie inny od oczekiwanego możesz przerwać i zwrócić false
if (buttons[index].Text != player.ToString())
{
return(false);
}
}
return(true);
}
// Use this for initialization
void Start()
{
m_PlayerUnit = new PlayerMarker();
//PlayerRigidBody = this.GetComponent<Rigidbody>();
m_PlayerUnit.Body = PlayerRigidBody;
OnFinish = delegate {
//TODO stateMachine.ChangeState(PlayerCountState);
};
m_SelectUnit = new SelectMarker();
m_SelectUnit.Body = MarkerRigidBody;
m_PlayerUnit.SelectPosition = m_PlayerUnit.NewPosition =
m_SelectUnit.SelectPosition = m_SelectUnit.NewPosition = transform.position;
((IGridMover)m_Mover).SetMap(null);
}
public void SetPlayerStart()
{
// If any player marker still exists, destroy it
PlayerMarker[] oldPlayerMarkers = FindObjectsOfType <PlayerMarker>();
foreach (PlayerMarker oldMarker in oldPlayerMarkers)
{
Destroy(oldMarker.gameObject);
}
SetPlayerPosition();
PlayerMarker playerMarkerPrefab = parentRow.GetMapGrid().GetPlayerMarkerPrefab();
Vector3 markerPosition = GetPlayerMarkerPosition();
PlayerMarker newPlayerMarker = Instantiate(playerMarkerPrefab, markerPosition, Quaternion.identity);
newPlayerMarker.SetCurrentSquare(this);
}
// sprwadź na skoks od lewej do prawej
bool CheckWinningPatternDiagonallyRight(PlayerMarker player)
{
bool win = true;
for (int y = 0; y < Settings.BoardSize; ++y)
{
for (int x = 0; x < Settings.BoardSize; ++x)
{
int index = (y * Settings.BoardSize) + x;
if (x == y)
{
if (buttons[index].Text != player.ToString())
{
win = false;
}
}
}
}
return(win);
}
public void setMarker(PlayerMarker marker, int i, int j)
{
if (i < 0)
{
i = 0;
}
else if (i > 5)
{
i = 5;
}
if (j < 0)
{
j = 0;
}
else if (j > 7)
{
j = 7;
}
marker.SetPos(i, j);
}
// sprawdź na skosk do prawej do lewej
bool CheckWinningPatternDiagonallyLeft(PlayerMarker player)
{
bool win = true;
for (int y = Settings.BoardSize; y > 0; --y)
{
for (int x = Settings.BoardSize; x > 0; --x)
{
int index = (y * Settings.BoardSize) - x;
if (x == y)
{
if (buttons[index].Text != player.ToString())
{
win = false;
}
}
}
}
return(win);
}
void PerformPCMove(PlayerMarker player)
{
// Ruch komputera, można zaimplementować coś z...
https: //en.wikipedia.org/wiki/Tic-tac-toe
// wybierz losowe wolne pole
System.Random rand = new Random();
List <int> emptyIndexes = new List <int>();
for (int i = 0; i < buttons.Count(); ++i)
{
if (buttons[i].Text == String.Empty) // sprawdź które przyciski są puste
{
emptyIndexes.Add(i); // dodaj indeks to listy
}
}
int selectedIndex = rand.Next(0, emptyIndexes.Count()); // wylosuj indeks wolnego pola
buttons[emptyIndexes[selectedIndex]].Text = player.ToString(); // użyj go aby wykonać ruch
}
public PlayerMarkerWindow(PlayerMarker marker)
{
InitializeComponent();
if (marker != null)
{
_isEditMode = true;
_marker = marker;
_oldName = _marker.Name;
this.Title = TryFindResource("EditButtonText") as String + " " + this.Title;
NameTextBox.Text = _marker.Name;
MarkerColorPicker.SelectedColorAsHex = _marker.Color;
}
else
{
this.Title = TryFindResource("AddButtonText") as String + " " + this.Title;
_isEditMode = false;
}
}
//Adds marker to zone if possible, else return it back
public void AttachMarker(PlayerMarker p)
{
if(this==p.myZone)
{
p.Revert ();
return;
}
int OpenSlots = mySlots.Count - myMarkers.Count;
switch (OpenSlots)
{
case 0:
//no slots, revert
p.Revert ();
Debug.Log ("no slots");
break;
case 1:
//go mid
DetachMarker(p);
Move(p, SlotType.M);
myMarkers.Add (p);
break;
case 3:
//go mid
DetachMarker(p);
Move(p, SlotType.M);
myMarkers.Add (p);
break;
case 2:
//go left, mid goes right
DetachMarker(p);
Move (p, SlotType.L);
myMarkers.Add (p);
Move (myMarkers[0], SlotType.R);
break;
}
}
//Atttach player to the marker
public void Apply( PlayerMarker m, FPlayer p)
{
m.LinkedPlayer = p;
}
void Awake()
{
_player = FindObjectOfType <PlayerMarker>();
_health = _player?.GetComponent <Health>();
_healthText = GetComponent <TextMeshProUGUI>();
}
public void DetachMarker(PlayerMarker p)
{
//no detach on first attach
if(p.myZone == null)
{
return;
}
int Slots = p.myZone.mySlots.Count;
int Markers = p.myZone.myMarkers.Count;
int OpenSlots = Slots - Markers;
Debug.Log (OpenSlots);
if (OpenSlots==0 && Slots==1)
{
//
p.myZone.myMarkers.Remove(p);
return;
}
switch(OpenSlots)
{
case 2:
//return, only one slot occupied
p.myZone.myMarkers.Remove(p);
return;
case 1:
//
foreach(PlayerMarker pp in p.myZone.myMarkers.ToArray())
{
if(pp!=p)
{
Debug.Log ("move to mid");
FixPositions (pp,SlotType.M);
p.myZone.myMarkers.Remove(p);
return;
}
}
break;
case 0:
//if mid - ok, left: mid go right, right: mid gp left
switch(p.mySlot.Type)
{
case SlotType.M:
// mid, ok, remove
p.myZone.myMarkers.Remove(p);
break;
case SlotType.L:
//left, mid go right
foreach(PlayerMarker pp in p.myZone.myMarkers.ToArray())
{
if(pp.mySlot.Type==SlotType.M)
{
FixPositions(pp, SlotType.L);
p.myZone.myMarkers.Remove(p);
return;
}
}
break;
case SlotType.R:
//right, mid goes left
foreach(PlayerMarker pp in p.myZone.myMarkers.ToArray())
{
if(pp.mySlot.Type==SlotType.M)
{
FixPositions (pp, SlotType.R);
p.myZone.myMarkers.Remove(p);
return;
}
}
break;
}
break;
}
}
//finds slot, assign value and move marker
void Move(PlayerMarker p, SlotType s)
{
FieldSlot t;
foreach(FieldSlot f in mySlots)
{
if(f.Type==s)
{
t=f;
p.myZone=this;
p.mySlot=t;
p.transform.position=t.transform.position;
break;
}
}
}
//set correct position for markers in left zone
void FixPositions(PlayerMarker o, SlotType s)
{
foreach(FieldSlot f in o.myZone.mySlots)
{
if(f.Type==s)
{
o.transform.position=f.transform.position;
break;
}
}
}
private void Awake()
{
_playerMarker = FindObjectOfType <PlayerMarker>();
_playerXpLevelHandler = _playerMarker?.GetComponent <PlayerXpLevelHandler>();
gameCurrentLevel = _playerXpLevelHandler.CurrentLevel;
}
private void SaveButton_Click(object sender, RoutedEventArgs e)
{
if (!(this.DataContext is ObservableCollection <PlayerMarker> context))
{
return;
}
string inputName = NameTextBox.Text;
string colorText = MarkerColorPicker.SelectedColorAsHex;
// Validate if input information is OK
if (String.IsNullOrWhiteSpace(inputName))
{
MessageBox.Show
(
TryFindResource("PlayerMarkerNameIsEmptyErrorText") as String,
TryFindResource("ErrorTitle") as String,
MessageBoxButton.OK,
MessageBoxImage.Error
);
return;
}
if (String.IsNullOrWhiteSpace(colorText))
{
MessageBox.Show
(
TryFindResource("PlayerMarkerColorIsEmptyErrorText") as String,
TryFindResource("ErrorTitle") as String,
MessageBoxButton.OK,
MessageBoxImage.Error
);
return;
}
// Check if name already exists
if (!_isEditMode) // If we are creating a new item, no need to check old name collision
{
var existingItem = context.Where
(
x => x.Name.Equals(inputName, StringComparison.OrdinalIgnoreCase)
).FirstOrDefault();
// Name does not exist
if (existingItem != null)
{
MessageBox.Show
(
(TryFindResource("PlayerMarkerAlreadyExistsErrorText") as String).Replace("$", inputName),
TryFindResource("PlayerMarkerAlreadyExistsErrorTitle") as String,
MessageBoxButton.OK,
MessageBoxImage.Error
);
return;
}
// New one, add it!!!!!
var newMarker = new PlayerMarker
{
Name = inputName,
Color = colorText
};
context.Add(newMarker);
this.Close();
}
else
{
// Make sure you aren't changing the name to another marker
var existingItem = context.Where
(
x => x.Name.Equals(inputName, StringComparison.OrdinalIgnoreCase) &&
!x.Name.Equals(_oldName, StringComparison.OrdinalIgnoreCase)
).FirstOrDefault();
// Name does not exist
if (existingItem != null)
{
MessageBox.Show
(
(TryFindResource("PlayerMarkerAlreadyExistsErrorText") as String).Replace("$", inputName),
TryFindResource("PlayerMarkerAlreadyExistsErrorTitle") as String,
MessageBoxButton.OK,
MessageBoxImage.Error
);
return;
}
// New one, add it!!!!!
_marker.Name = inputName;
_marker.Color = colorText;
this.Close();
}
}
private void Awake()
{
_player = FindObjectOfType <PlayerMarker>();
_follower = GetComponent <Follower>();
}
private IEnumerator DoInitialize()
{
eventData = (SectionEventData)GameSection.GetEventData();
if (MonoBehaviourSingleton <InGameManager> .IsValid())
{
portalData = Singleton <FieldMapTable> .I.GetPortalData(MonoBehaviourSingleton <InGameManager> .I.beforePortalID);
}
if (MonoBehaviourSingleton <OutGameSettingsManager> .IsValid() && portalData == null)
{
portalData = Singleton <FieldMapTable> .I.GetPortalData((uint)MonoBehaviourSingleton <OutGameSettingsManager> .I.homeScene.linkFieldPortalID);
}
if (eventData.IsQuestToField())
{
portalData = Singleton <FieldMapTable> .I.GetPortalData(MonoBehaviourSingleton <FieldManager> .I.currentPortalID);
}
if (portalData == null)
{
base.Initialize();
}
else
{
FieldMapTable.FieldMapTableData currentMapData = Singleton <FieldMapTable> .I.GetFieldMapData(portalData.srcMapID);
newMapData = Singleton <FieldMapTable> .I.GetFieldMapData(portalData.dstMapID);
regionId = newMapData.regionId;
if (NeedDirectionOpenRegion())
{
toRegionRelease = true;
base.Initialize();
}
else
{
if (currentMapData != null && newMapData != null && newMapData.regionId != currentMapData.regionId)
{
regionId = currentMapData.regionId;
}
if (newMapData == null || !IsValidRegion(newMapData))
{
newMapData = null;
base.Initialize();
}
else
{
LoadingQueue loadQueue = new LoadingQueue(this);
LoadObject loadedEventUIRoot = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "NewFieldOpenEventUIRoot", false);
LoadObject loadedLocationSpot = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "LocationSpot", false);
LoadObject loadedEventCamera = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "NewFieldEventCamera", false);
LoadObject loadedFilterCamera = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "ZoomBlurFilterCamera", false);
LoadObject loadedPlayerMarker = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "PlayerMarker", false);
LoadObject loadedRegion = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "RegionMap_" + regionId.ToString("D3"), false);
LoadObject loadedEffect = loadQueue.LoadEffect(RESOURCE_CATEGORY.EFFECT_UI, "ef_ui_map_fire_01", false);
LoadObject loadedWindEffect = loadQueue.LoadEffect(RESOURCE_CATEGORY.EFFECT_ACTION, "ef_btl_bg_questmap_01", false);
LoadObject loadedDungeonEff = null;
if (eventData.IsFindNewDungeon() && newMapData != null)
{
uint mapID = newMapData.mapID;
loadedDungeonEff = loadQueue.LoadEffect(RESOURCE_CATEGORY.EFFECT_DUNGEON, "DEF_" + mapID.ToString("D8"), false);
}
LoadObject loadedEncounterBossCutIn = null;
if (eventData.IsEncounterBossEvent())
{
loadedEncounterBossCutIn = loadQueue.Load(RESOURCE_CATEGORY.UI, "InGameFieldQuestWarning", false);
}
CacheAudio(loadQueue);
if (loadQueue.IsLoading())
{
yield return((object)loadQueue.Wait());
}
if (loadedEncounterBossCutIn != null)
{
fieldQuestWarningRoot = ResourceUtility.Realizes(loadedEncounterBossCutIn.loadedObject, -1).get_gameObject();
UIPanel panel = fieldQuestWarningRoot.GetComponentInChildren <UIPanel>();
if (panel != null)
{
panel.depth = 8000;
}
if (MonoBehaviourSingleton <UIInGameFieldQuestWarning> .IsValid())
{
MonoBehaviourSingleton <UIInGameFieldQuestWarning> .I.Load(loadQueue);
}
}
if (loadQueue.IsLoading())
{
yield return((object)loadQueue.Wait());
}
topEffectPrefab = loadedEffect.loadedObject;
Transform t = ResourceUtility.Realizes(loadedEventUIRoot.loadedObject, base._transform, -1);
regionMapRoot = ResourceUtility.Realizes(loadedRegion.loadedObject, MonoBehaviourSingleton <AppMain> .I._transform, -1).get_gameObject().GetComponent <RegionMapRoot>();
if (regionMapRoot != null)
{
bool wait = true;
regionMapRoot.InitPortalStatus(delegate
{
((_003CDoInitialize_003Ec__Iterator164) /*Error near IL_0526: stateMachine*/)._003Cwait_003E__15 = false;
});
while (wait)
{
yield return((object)null);
}
}
blurFilter = (ResourceUtility.Instantiate <Object>(loadedFilterCamera.loadedObject) as GameObject).GetComponent <ZoomBlurFilter>();
blurFilter.get_transform().set_parent(base._transform);
_camera = ResourceUtility.Realizes(loadedEventCamera.loadedObject, MonoBehaviourSingleton <AppMain> .I._transform, -1).GetComponent <Camera>();
uiFrontMapSprite = t.FindChild("FrontMap").get_gameObject().GetComponent <UITexture>();
if (uiFrontMapSprite != null)
{
uiFrontMapSprite.alpha = 0f;
}
uiMapSprite = t.FindChild("Map").get_gameObject().GetComponent <UITexture>();
InitMapSprite(MonoBehaviourSingleton <ScreenOrientationManager> .I.isPortrait);
if (eventData.IsEncounterBossEvent())
{
t.FindChild("TaptoSkip").get_gameObject().SetActive(false);
}
bgEventListener = UIEventListener.Get(t.Find("BG").get_gameObject());
tutorialTrigger = t.FindChild("TUTORIAL_TRIGGER");
if (tutorialTrigger != null)
{
if (!TutorialStep.HasAllTutorialCompleted())
{
tutorialTrigger.get_gameObject().SetActive(true);
UITweenCtrl.Play(tutorialTrigger, true, null, false, 0);
}
else
{
tutorialTrigger.get_gameObject().SetActive(false);
}
}
spots = new SpotManager(null, loadedLocationSpot.loadedObject as GameObject, _camera);
spots.spotRootTransform = t;
playerMarker = ResourceUtility.Realizes(loadedPlayerMarker.loadedObject, -1);
PlayerMarker playerMarkerCom = playerMarker.GetComponent <PlayerMarker>();
if (null != playerMarkerCom)
{
playerMarkerCom.SetCamera(_camera.get_transform());
}
windEffect = ResourceUtility.Realizes(loadedWindEffect.loadedObject, _camera.get_transform(), -1).get_gameObject().GetComponent <rymFX>();
windEffect.Cameras = (Camera[])new Camera[1]
{
_camera
};
windEffect.get_gameObject().set_layer(LayerMask.NameToLayer("WorldMap"));
if (loadedDungeonEff != null)
{
dungeonOpenEffect = ResourceUtility.Realizes(loadedDungeonEff.loadedObject, base._transform, -1);
dungeonOpenEffect.get_gameObject().SetActive(false);
}
CreateVisitedLocationSpot();
if (MonoBehaviourSingleton <GameSceneManager> .I.GetCurrentSceneName() == "InGameScene")
{
MonoBehaviourSingleton <ScreenOrientationManager> .I.OnScreenRotate += InitMapSprite;
}
base.Initialize();
}
}
}
}
private void SaveButton_Click(ContentDialog sender, ContentDialogButtonClickEventArgs args)
{
if (!(this.DataContext is ObservableCollection <PlayerMarker> context))
{
return;
}
string inputName = NameTextBox.Text;
string noteText = NoteTextBox.Text;
string colorText = MarkerColorPicker.SelectedColorHex;
// Hide error, reset the block
_blockClose = false;
// Validate if input information is OK
if (String.IsNullOrWhiteSpace(inputName))
{
// Show error
_blockClose = true;
var flyout = FlyoutHelper.CreateFlyout(includeButton: false);
flyout.SetFlyoutLabelText(TryFindResource("PlayerMarkerNameIsEmptyErrorText") as String);
flyout.ShowAt(NameTextBox);
return;
}
// Check if name already exists
if (!_isEditMode) // If we are creating a new item, no need to check old name collision
{
var existingItem = context.Where
(
x => x.Name.Equals(inputName, StringComparison.OrdinalIgnoreCase)
).FirstOrDefault();
// Name already exists
if (existingItem != null)
{
_blockClose = true;
var errorText = (TryFindResource("PlayerMarkerAlreadyExistsErrorText") as String)
.Replace("$", inputName);
var flyout = FlyoutHelper.CreateFlyout(includeButton: false);
flyout.SetFlyoutLabelText(errorText);
flyout.ShowAt(NameTextBox);
return;
}
// New one, add it!!!!!
var newMarker = new PlayerMarker
{
Name = inputName,
Color = colorText,
Note = noteText
};
context.Add(newMarker);
this.Hide();
}
else
{
// Make sure you aren't changing the name to another marker
var existingItem = context.Where
(
x => x.Name.Equals(inputName, StringComparison.OrdinalIgnoreCase) &&
!x.Name.Equals(_oldName, StringComparison.OrdinalIgnoreCase)
).FirstOrDefault();
// Name already exists
if (existingItem != null)
{
_blockClose = true;
var errorText = (TryFindResource("PlayerMarkerAlreadyExistsErrorText") as String)
.Replace("$", inputName);
var flyout = FlyoutHelper.CreateFlyout(includeButton: false);
flyout.SetFlyoutLabelText(errorText);
flyout.ShowAt(NameTextBox);
return;
}
// New one, add it!!!!!
_marker.Name = inputName;
_marker.Color = colorText;
_marker.Note = noteText;
this.Hide();
}
}
private void Awake()
{
_baseStatsGetter = GetComponent <IBaseStatsGetter>();
_playerMarker = FindObjectOfType <PlayerMarker>();
}
static void Main(string[] args)
{
string teamName = "Benfica FC";
string formation = "4-3-1-2";
try
{
using (Image <Rgba32> image = new Image <Rgba32>(650, 650))
{
var field = new RectangularPolygon(new PointF(0, 64), new PointF(650, 650));
var penaltybox = new RectangularPolygon(new PointF(0, 160), new PointF(155, 544));
var gkbox = new RectangularPolygon(new PointF(0, 275), new PointF(55, 430));
var midLine = new RectangularPolygon(new PointF(500, 64), new PointF(660, 660));
var midCircle = new EllipsePolygon(new PointF(500, 353), 90);
var penaltySpot = new EllipsePolygon(new PointF(100, 352), 2);
var arc = new Polygon(new CubicBezierLineSegment(new PointF[] {
new PointF(155, 280),
new PointF(210, 300),
new PointF(210, 405),
new PointF(155, 425)
}));
var textGraphicsOptions = new TextGraphicsOptions(true);
var formationFont = SystemFonts.CreateFont("Trebuchet MS", _formationFontSize, FontStyle.Regular);
var teamFont = SystemFonts.CreateFont("Trebuchet MS", _teamNameFontSize, FontStyle.Regular);
var playerFont = SystemFonts.CreateFont("Trebuchet MS", _playerNameFontSize, FontStyle.Regular);
RendererOptions teamOptions = new RendererOptions(formationFont, textGraphicsOptions.DpiX, textGraphicsOptions.DpiY)
{
HorizontalAlignment = textGraphicsOptions.HorizontalAlignment,
TabWidth = textGraphicsOptions.TabWidth,
VerticalAlignment = textGraphicsOptions.VerticalAlignment,
WrappingWidth = textGraphicsOptions.WrapTextWidth,
ApplyKerning = textGraphicsOptions.ApplyKerning
};
RendererOptions formationOptions = new RendererOptions(formationFont, textGraphicsOptions.DpiX, textGraphicsOptions.DpiY)
{
HorizontalAlignment = HorizontalAlignment.Right,
TabWidth = textGraphicsOptions.TabWidth,
VerticalAlignment = textGraphicsOptions.VerticalAlignment,
WrappingWidth = textGraphicsOptions.WrapTextWidth,
ApplyKerning = textGraphicsOptions.ApplyKerning
};
RendererOptions playerOptions = new RendererOptions(playerFont, textGraphicsOptions.DpiX, textGraphicsOptions.DpiY)
{
HorizontalAlignment = HorizontalAlignment.Center,
TabWidth = textGraphicsOptions.TabWidth,
VerticalAlignment = textGraphicsOptions.VerticalAlignment,
WrappingWidth = textGraphicsOptions.WrapTextWidth,
ApplyKerning = textGraphicsOptions.ApplyKerning
};
var teamGlyph = TextBuilder.GenerateGlyphs(teamName, new PointF(20, 28), teamOptions);
var formationGlyph = TextBuilder.GenerateGlyphs(formation, new PointF(630, 28), formationOptions);
//var playerGlyph = TextBuilder.GenerateGlyphs(formation, new PointF(630, 28), playerOptions);
image.Mutate(ctx => ctx
.Fill(new Rgba32(237, 237, 237))
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, teamGlyph)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, formationGlyph)
.Fill(new GraphicsOptions(true), new Rgba32(158, 209, 171), field)
.Draw(new Rgba32(180, 230, 193), 3, arc)
.Draw(new Rgba32(180, 230, 193), 3, penaltybox)
.Draw(new Rgba32(180, 230, 193), 3, gkbox)
.Draw(new Rgba32(180, 230, 193), 3, midLine)
.Draw(new Rgba32(180, 230, 193), 3, midCircle)
.Draw(new Rgba32(180, 230, 193), 3, penaltySpot)
);
List <Player> players = GetPlayers();
playerMarkers = new Dictionary <string, List <PlayerMarker> >();
foreach (Player p in players)
{
PlayerMarker marker = new PlayerMarker()
{
Info = p
};
if (!playerMarkers.ContainsKey(p.Position))
{
List <PlayerMarker> playerInPosition = new List <PlayerMarker>();
playerInPosition.Add(marker);
playerMarkers.Add(p.Position, playerInPosition);
}
else
{
playerMarkers[p.Position].Add(marker);
}
}
ProcessPosition("LB", _baseXb, _baseYL, true);
ProcessPosition("RB", _baseXb, _baseYR, true);
ProcessPosition("CB", _baseXb, 0, false);
ProcessPosition("DM", _baseXdm, 0, false);
ProcessPosition("LM", _baseXm, _baseYL, true);
ProcessPosition("RM", _baseXm, _baseYR, true);
ProcessPosition("CM", _baseXm, 0, false);
ProcessPosition("AM", _baseXam, 0, false);
ProcessPosition("LF", _baseXf, _baseYL, true);
ProcessPosition("RF", _baseXf, _baseYR, true);
ProcessPosition("CF", _baseXf, 0, false);
Console.WriteLine(JsonConvert.SerializeObject(playerMarkers));
List <PlayerMarker> finalPositions = new List <PlayerMarker>();
foreach (var i in playerMarkers.Values)
{
foreach (var p in i)
{
p.Marker = new EllipsePolygon(new PointF(p.posX, p.posY), 15);
finalPositions.Add(p);
}
}
foreach (var p in finalPositions)
{
image.Mutate(ctx => ctx
.Fill(new GraphicsOptions(true), new Rgba32(237, 237, 237), p.Marker)
.Draw(new Rgba32(155, 186, 217), 1, p.Marker)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, TextBuilder.GenerateGlyphs(p.Info.Position, new PointF(p.posX, p.posY - 4), playerOptions))
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, TextBuilder.GenerateGlyphs(p.Info.Name, new PointF(p.posX, p.posText), playerOptions))
);
}
image.Save("output/wordart.png");
}
}
finally
{
}
}
//this method could be overriden in a subclass to implement specific pickups
//as an example, this is an ammo pickup
protected virtual void Pick(PlayerMarker player)
{
Debug.Log("Picked up");
player.GetComponent <PlayerAttack>().Weapon.Ammo += 10;
}
void Awake()
{
_player = FindObjectOfType <PlayerMarker>();
_playerMaxXpHandler = _player?.GetComponent <PlayerMaxXpHandler>();
_xpText = GetComponent <TextMeshProUGUI>();
}
private void Awake()
{
_player = FindObjectOfType <PlayerMarker>();
_playerMaxXpHandler = _player?.GetComponent <PlayerMaxXpHandler>();
_experience = _player?.GetComponent <Experience>();
}
void Awake()
{
_player = FindObjectOfType <PlayerMarker>();
_experience = _player?.GetComponent <Experience>();
_xpText = GetComponent <TextMeshProUGUI>();
}
