static void Main(string[] args)
{
CustomGame cg = new CustomGame();
Team volunteerForTeam = Team.Red;
cg.Chat.SendChatMessage($"Type $VOLUNTEER to volunteer for {volunteerForTeam}.");
PlayerTracker tracker = new PlayerTracker();
cg.Commands.Listen = true;
cg.Commands.ListenTo.Add(new ListenTo("$VOLUNTEER", true, true, true, (cd) => Volunteer(cg, tracker, cd, volunteerForTeam)));
Task.Run(() =>
{
while (true)
{
cg.TrackPlayers(tracker);
Thread.Sleep(25);
}
});
while (true)
{
cg.Chat.SendChatMessage(Console.ReadLine());
}
}
private void UpdateServerStartButton()
{
int[] teams = TeamTracker.GetInstance().GetTeams();
if (teams[0] == 0 || teams[1] == 0)
{
startGameButtonText.text = "Waiting for teams";
allowServerStart = false;
return;
}
bool allReady = true;
foreach (GameObject player in PlayerTracker.GetInstance().GetPlayers())
{
if (!player)
{
continue;
}
PlayerDataForClients settings = player.GetComponent <PlayerDataForClients>();
if (!settings.GetIsReadyFlag() && !settings.GetIsServerFlag())
{
allReady = false;
}
}
startGameButtonText.text = allReady ? "Start game" : "Waiting on ready";
allowServerStart = allReady;
}
/// <summary>Update the watchers and adjust for added or removed entities.</summary>
public void Update()
{
// reset player
if (Context.IsWorldReady)
{
if (this.CurrentPlayerTracker == null || this.CurrentPlayerTracker.Player != Game1.player)
{
this.CurrentPlayerTracker?.Dispose();
this.CurrentPlayerTracker = new PlayerTracker(Game1.player);
}
}
else
{
if (this.CurrentPlayerTracker != null)
{
this.CurrentPlayerTracker.Dispose();
this.CurrentPlayerTracker = null;
}
}
// update values
foreach (IWatcher watcher in this.Watchers)
{
watcher.Update();
}
this.CurrentPlayerTracker?.Update();
this.LocationsWatcher.Update();
}
void Awake()
{
if (!isLocalPlayer)
{
instance = this;
}
}
private IEnumerator GetSteps()
{
UnityWebRequest www = UnityWebRequest.Get(
"http://hunction2018.herokuapp.com/products");
yield return(www.SendWebRequest());
if (www.isNetworkError)
{
Debug.Log("Network error: " + www.error);
}
if (www.isHttpError)
{
Debug.Log("Http error: " + www.error);
}
string sJason = www.downloadHandler.text;
Debug.Log("List " + sJason);
var tempSteps = PlayerTracker.getJsonArray <Step>(sJason);
if (tempSteps != null)
{
Debug.Log("Got " + tempSteps.Length + " steps");
steps = tempSteps;
currentStepIdx = 0;
}
else
{
Debug.Log("tempSteps is null");
}
}
public SkillResult(EachSkillResultServerMessage message, EntityTracker entityRegistry,
PlayerTracker playerTracker, SkillDatabase skillDatabase)
{
Time = message.Time;
Amount = message.Amount;
IsCritical = message.IsCritical;
IsHeal = message.IsHeal;
SkillId = message.SkillId;
Source = entityRegistry.GetOrPlaceholder(message.Source);
Target = entityRegistry.GetOrPlaceholder(message.Target);
var userNpc = UserEntity.ForEntity(Source);
var npc = (NpcEntity)userNpc["source"];
var sourceUser = userNpc["root_source"] as UserEntity; // Attribute damage dealt by owned entities to the owner
var targetUser = Target as UserEntity; // But don't attribute damage received by owned entities to the owner
if (sourceUser != null)
{
Skill = skillDatabase.Get(sourceUser, message);
if (Skill == null && npc != null)
{
Skill = new UserSkill(message.SkillId, sourceUser.RaceGenderClass, npc.Info.Name);
}
SourcePlayer = playerTracker.Get(sourceUser.PlayerId);
if (Skill == null)
{
Skill = new UserSkill(message.SkillId, sourceUser.RaceGenderClass, "Unknown");
}
}
if (targetUser != null)
{
TargetPlayer = playerTracker.Get(targetUser.PlayerId);
}
}
public SkillResult(EachSkillResultServerMessage message, EntityTracker entityRegistry, PlayerTracker playerTracker, SkillDatabase skillDatabase)
{
Time = message.Time;
Amount = message.Amount;
IsCritical = message.IsCritical;
IsHeal = message.IsHeal;
SkillId = message.SkillId;
Debug.Assert(!message.IsUseless);
Source = entityRegistry.GetOrPlaceholder(message.Source);
Target = entityRegistry.GetOrPlaceholder(message.Target);
var sourceUser = UserEntity.ForEntity(Source); // Attribute damage dealt by owned entities to the owner
var targetUser = Target as UserEntity; // But don't attribute damage received by owned entities to the owner
if (sourceUser != null)
{
Skill = skillDatabase.Get(sourceUser, message);
SourcePlayer = playerTracker.Get(sourceUser.PlayerId);
}
if (targetUser != null)
{
TargetPlayer = playerTracker.Get(targetUser.PlayerId);
}
}
public SkillResult(int amount, bool isCritical, bool isHp, bool isHeal, HotDot hotdot, EntityId source,
EntityId target, DateTime time,
EntityTracker entityRegistry, PlayerTracker playerTracker)
{
Time = time;
Amount = isHp ? Math.Abs(amount) : amount;
IsCritical = isCritical;
IsHp = isHp;
IsHeal = isHeal;
SkillId = hotdot.Id;
Abnormality = true;
Source = entityRegistry.GetOrPlaceholder(source);
Target = entityRegistry.GetOrPlaceholder(target);
var userNpc = UserEntity.ForEntity(Source);
var sourceUser = userNpc["root_source"] as UserEntity; // Attribute damage dealt by owned entities to the owner
var targetUser = Target as UserEntity; // But don't attribute damage received by owned entities to the owner
var pclass = PlayerClass.Common;
if (sourceUser != null)
{
SourcePlayer = playerTracker.Get(sourceUser.ServerId, sourceUser.PlayerId);
pclass = SourcePlayer.RaceGenderClass.Class;
}
Skill = new UserSkill(hotdot.Id, pclass,
hotdot.Name, "DOT", null, hotdot.IconName);
if (targetUser != null)
{
TargetPlayer = playerTracker.Get(targetUser.ServerId, targetUser.PlayerId);
}
HitDirection = HitDirection.Dot;
}
public static bool Prefix(ref SectionType __result, PlayerTracker __instance, Vector3 ___boundingBoxRange, List <Entity> ___npcs)
{
GameManager.Instance.World.GetEntitiesInBounds(typeof(EntityNPC), new Bounds(GameManager.Instance.World.GetPrimaryPlayer().position, ___boundingBoxRange), ___npcs);
if (___npcs.Count > 0)
{
EntityNPC entityNPC = ___npcs[0] as EntityNPC;
if (entityNPC != null)
{
string npcID = entityNPC.npcID;
if (npcID == "traitorjoel")
{
return(true);
}
if (npcID == "traderjen")
{
return(true);
}
if (npcID == "traderbob")
{
return(true);
}
if (npcID == "traderhugh")
{
return(true);
}
if (npcID == "traderrekt")
{
return(true);
}
}
}
__result = SectionType.None;
return(false);
}
void Start()
{
cameraTransform = ourCamera.transform;
targetTransform = target.transform;
cameraTransform.position = targetTransform.position;
originalCameraPos = cameraTransform.transform.rotation;
instance = this;
}
public DamageTracker(EntityTracker entityRegistry, PlayerTracker playerTracker, SkillDatabase skillDatabase)
{
_entityTracker = entityRegistry;
_skillDatabase = skillDatabase;
_playerTracker = playerTracker;
TotalDealt = new SkillStats();
TotalReceived = new SkillStats();
}
// Use this for initialization
void Start()
{
// Getting the component of the rigid body
rb2d = GetComponent <Rigidbody2D>();
// Getting the stats class
m_playerStats = GameObject.FindGameObjectWithTag("PlayerTracker").GetComponent <PlayerTracker>();
}
public void Start()
{
foreach (GameObject player in PlayerTracker.GetInstance().GetPlayers())
{
AddColourChangeEvent(player);
}
PlayerTracker.GetInstance().OnPlayerAdded += AddColourChangeEvent;
}
void Start()
{
if (enemyAI != null)
{
playerTracker = enemyAI.PlayerTracker;
playerTransform = enemyAI.Player.transform;
}
}
void Start()
{
enemyBody = GetComponent <Rigidbody2D>();
enemyBody.constraints = RigidbodyConstraints2D.FreezeRotation;
enemyHealth = GetComponent <HealthSystem>();
status = GetComponent <EnemyStatus>();
tracker = GetComponentInChildren <PlayerTracker>();
}
private void UpdateScoreboard()
{
SortedDictionary <int, List <GameObject> > scores = new SortedDictionary <int, List <GameObject> >(new DescendingComparer <int>());
if (scoreboardEntryPrefab == null)
{
return;
}
foreach (GameObject player in PlayerTracker.GetInstance().GetPlayers())
{
if (player == null || player.GetComponent <PlayerDataForClients>() == null)
{
continue;
}
int team = player.GetComponent <PlayerDataForClients>().GetTeam();
if (team == PlayerDataForClients.TEAM_SPECTATOR)
{
continue;
}
GameObject entry = Instantiate(scoreboardEntryPrefab);
ScoreboardEntryUI ui = entry.GetComponent <ScoreboardEntryUI>();
ui.SetName(player.GetComponent <PlayerDataForClients>().GetName());
int score = player.GetComponent <PlayerDataForClients>().GetScore();
ui.SetScore(score);
if (player == PlayerTracker.GetInstance().GetLocalPlayer())
{
ui.FlagCurrentPlayer();
}
entry.transform.SetParent(scoreboardViewport.transform, false);
if (!scores.ContainsKey(score))
{
scores.Add(score, new List <GameObject>());
}
scores[score].Add(entry);
}
int counter = 0;
foreach (KeyValuePair <int, List <GameObject> > values in scores)
{
foreach (GameObject player in values.Value)
{
Vector3 localPos = player.GetComponent <RectTransform>().localPosition;
player.GetComponent <RectTransform>().localPosition = new Vector3(localPos.x, -(entryPrefabHeight / 2) + (-(entryPrefabHeight + 2) * counter), localPos.z);
counter++;
}
}
RectTransform transform = scoreboardViewport.GetComponent <RectTransform>();
transform.sizeDelta = new Vector2(transform.sizeDelta.x, counter * (entryPrefabHeight + 2));
}
/// <summary>Update the tracked values.</summary>
/// <param name="watcher">The player watcher to snapshot.</param>
public void Update(PlayerTracker watcher)
{
this.Location.Update(watcher.LocationWatcher);
foreach (var pair in this.Skills)
{
pair.Value.Update(watcher.SkillWatchers[pair.Key]);
}
this.InventoryChanges = watcher.GetInventoryChanges().ToArray();
}
private void HandleNewConnection(Server server)
{
Text = $"Damage Meter connected to {server.Name}";
_server = server;
_teraData = BasicTeraData.DataForRegion(server.Region);
_entityRegistry = new EntityTracker();
_playerTracker = new PlayerTracker(_entityRegistry);
_damageTracker = new DamageTracker(_entityRegistry, _playerTracker, _teraData.SkillDatabase);
_messageFactory = new MessageFactory(_teraData.OpCodeNamer);
}
/// <summary>Update the tracked values.</summary>
/// <param name="watcher">The player watcher to snapshot.</param>
public void Update(PlayerTracker watcher)
{
this.Location.Update(watcher.LocationWatcher);
foreach (var pair in this.Skills)
pair.Value.Update(watcher.SkillWatchers[pair.Key]);
this.Inventory = watcher.TryGetInventoryChanges(out SnapshotItemListDiff itemChanges)
? itemChanges
: this.EmptyItemListDiff;
}
private void HandleNewConnection(Server server)
{
TeraData = BasicTeraData.Instance.DataForRegion(server.Region);
EntityTracker = new EntityTracker(BasicTeraData.Instance.MonsterDatabase);
PlayerTracker = new PlayerTracker(EntityTracker);
_messageFactory = new MessageFactory(TeraData.OpCodeNamer);
var handler = Connected;
handler?.Invoke(server.Name);
}
static void Volunteer(CustomGame cg, PlayerTracker tracker, CommandData cd, Team volunteerForTeam)
{
cg.TrackPlayers(tracker);
int slot = tracker.SlotFromPlayerIdentity(cd.PlayerIdentity);
if (CustomGame.IsSlotValid(slot) && !CustomGame.IsSlot(slot, volunteerForTeam))
{
cg.Interact.SwapTeam(slot);
cg.Chat.SendChatMessage($"Thanks for volunteering, {FormatName(cd.PlayerName)}!");
}
}
public void SetReadyState(bool isReady)
{
PlayerTracker.GetInstance().GetLocalPlayer().GetComponent <PlayerDataForClients>().SetIsReadyFlag(isReady);
if (readyWaitingButton == null || readyNowButton == null)
{
return;
}
readyWaitingButton.SetActive(!isReady);
readyNowButton.SetActive(isReady);
}
} // Pregame
private static void OnSwapMe(CommandData commandData, CustomGame cg, PlayerTracker playerTracker)
{
cg.TrackPlayers(playerTracker, SlotFlags.BlueAndRed);
int slot = playerTracker.SlotFromPlayerIdentity(commandData.PlayerIdentity);
if (slot != -1)
{
cg.Interact.SwapTeam(slot);
cg.Chat.SendChatMessage($"Swapping {commandData.PlayerName}'s team.");
}
}
private void HandleNewConnection(Server server, IPEndPoint serverIpEndPoint, IPEndPoint clientIpEndPoint)
{
TeraData = BasicTeraData.Instance.DataForRegion(server.Region);
EntityTracker = new EntityTracker();
PlayerTracker = new PlayerTracker(EntityTracker);
_messageFactory = new MessageFactory(TeraData.OpCodeNamer);
ServerIpEndPoint = serverIpEndPoint;
ClientIpEndPoint = clientIpEndPoint;
var handler = Connected;
handler?.Invoke(server.Name);
}
// on start instead of awake to make sure it happens afterwards (check if better way)
public void Start()
{
foreach (GameObject player in PlayerTracker.GetInstance().GetPlayers())
{
NewLobbyPlayerAdded(player);
}
PlayerTracker.GetInstance().OnPlayerAdded += NewLobbyPlayerAdded;
PlayerTracker.GetInstance().OnPlayerRemoved += OldLobbyPlayerRemoved;
TeamTracker.GetInstance().OnTeamChanged += UpdateVersusText;
TeamTracker.GetInstance().ForceRecount();
}
private void Update()
{
timer += Time.deltaTime;
if (timer >= 2f)
{
Destroy(gameObject);
}
PlayerTracker = GameObject.FindGameObjectWithTag("Tracker");
tracker = PlayerTracker.GetComponent <PlayerTracker>();
Player = tracker.Player;
playerStats = Player.GetComponent <PlayerStats>();
}
public void GetRoomData(LevelImport li)
{
li.dataAsset = (TextAsset)levelDat[currentLevel];
li.currentSprite = (Sprite)levelPic[currentLevel];
gameObject.GetComponent <AudioSource>().clip = musicToUse[currentLevel];
li.isFirstLevel = currentLevel == 0 ? true : false;
li.LoadLevel();
pt = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <PlayerTracker>();
pt.SetRightEdge(li.GetRoomWidth());
gameObject.GetComponent <AudioSource>().loop = true;
gameObject.GetComponent <AudioSource>().Play();
}
void Start()
{
Screen.sleepTimeout = SleepTimeout.NeverSleep;
playerTracker = this.GetComponent <PlayerTracker>();
resetButton.onClick.AddListener(ResetGyro);
Input.gyro.enabled = true;
Application.targetFrameRate = 60;
initialYAngle = transform.eulerAngles.y;
displayCoords.text = "aqui iran las coords";
lastTime = Time.time;
setaCubo = world.GetComponent <Cubo>();
}
public ActionResult <PlayerTracker> PostTracker(PlayerTrackerDTO pt)
{
PlayerTracker tracker = new PlayerTracker()
{
Username = pt.Username, Player_Id = pt.Player_Id, Server_Name = pt.Server_Name, World_Id = pt.World_Id
};
_context.Add(tracker);
_context.SaveChanges();
return(CreatedAtAction(nameof(GetTracker),
new { user = tracker.Username, player = tracker.Player_Id, server = tracker.Server_Name, world = tracker.World_Id }, tracker));
}
public void Awake()
{
if (State.GetInstance().Network() == State.NETWORK_SERVER)
{
SubscribeToServerPlaying();
foreach (GameObject player in PlayerTracker.GetInstance().GetPlayers())
{
ResetPlayerScore(player);
}
PlayerTracker.GetInstance().OnPlayerAdded += ResetPlayerScore;
}
}
// Use this for initialization
void Awake()
{
if (Instance == null)
{
Instance = this;
}
else
{
Destroy(gameObject);
}
thePC = FindObjectOfType <PlayerController>();
}
void Awake()
{
// Zuweisung der Variablen
#region
col = GetComponent<SphereCollider>();
playerTracker = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent<PlayerTracker>();
player = GameObject.FindGameObjectWithTag(Tags.player);
playerRigid = player.GetComponent<Rigidbody>();
playerMovement = player.GetComponent<Player_Movement>();
playerHealth = player.GetComponent<Player_Health>();
npcAI = GetComponent<NPC_AI>();
flashLight = GetComponentInChildren<NPC_Flashlight>();
#endregion
targetSightingPosition = playerTracker.resetPosition;
}
public float angleResponseTime = 0.6f; // Response time for turning an angle into angularSpeed.
void Awake()
{
// Zuweisung von Variablen
#region
initialPosition = new Vector3(transform.position.x, 0f, transform.position.z);
initialForward = transform.forward;
playerTracker = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent<PlayerTracker>();
npcSight = GetComponent<NPC_Sight>();
npcAI = GetComponent<NPC_AI>();
nav = GetComponent<NavMeshAgent>();
anim = GetComponent<Animator>();
hash = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent<HashIDs>();
#endregion
nav.updateRotation = false;
anim.SetLayerWeight(1, 0.9f);
anim.SetLayerWeight(2, 1f);
deadZone *= Mathf.Deg2Rad;
}
private void HandleNewConnection(Server server)
{
Server = server;
_teraData = BasicTeraData.DataForRegion(server.Region);
_entityTracker = new EntityTracker();
_playerTracker = new PlayerTracker(_entityTracker);
_messageFactory = new MessageFactory(_teraData.OpCodeNamer);
Reset(null);
DamageTracker = DamageTracker ?? new DamageTracker();
Logger.Info($"Connected to server {server.Name}.");
}
private void HandleMessageReceived(Message obj)
{
var message = _messageFactory.Create(obj);
if (DamageTracker.IsArchived)
{
var npcOccupier = message as SNpcOccupierInfo;
if (npcOccupier != null)
{
Entity ent = _entityTracker.GetOrPlaceholder(npcOccupier.NPC);
if (ent is NpcEntity)
{
var npce = ent as NpcEntity;
if (npce.Info.Boss && npcOccupier.Target != EntityId.Empty)
{
CasualMessenger.Instance.ResetPlayerStats(true); //Stop viewing saved encounter on boss aggro
}
}
return;
}
}
_entityTracker?.Update(message);
var skillResultMessage = message as EachSkillResultServerMessage;
if (skillResultMessage != null)
{
if (skillResultMessage.IsValid(DamageTracker))
{
var skillResult = new SkillResult(skillResultMessage, _entityTracker, _playerTracker, _teraData.SkillDatabase, null, _abnormalityTracker);
CheckUpdate(skillResult);
}
return;
}
_playerTracker?.UpdateParty(message);
_abnormalityTracker?.Update(message);
var despawnNpc = message as SDespawnNpc;
if (despawnNpc != null)
{
Entity ent = _entityTracker.GetOrPlaceholder(despawnNpc.Npc);
if (ent is NpcEntity)
{
var npce = ent as NpcEntity;
if (npce.Info.Boss && despawnNpc.Dead && !DamageTracker.IsArchived)
{ //no need to do something if we didn't count any skill against this boss
if (DamageTracker.StatsByUser.SelectMany(x => x.SkillLog).Any(x => x.Target == npce))
{
DamageTracker.PrimaryTarget = npce; //Name encounter with the last dead boss
DamageTracker.IsPrimaryTargetDead = despawnNpc.Dead;
//determine type
ExportType exportType = ExportType.None;
if (SettingsHelper.Instance.Settings.ExcelExport)
exportType = exportType | ExportType.Excel;
if (SettingsHelper.Instance.Settings.SiteExport)
exportType = exportType | ExportType.Upload;
if (exportType != ExportType.None)
DataExporter.ToTeraDpsApi(exportType, DamageTracker, _teraData);
if (AutosaveEncounters)
ResetDamageTracker(new ResetPlayerStatsMessage { ShouldSaveCurrent = true });
}
}
}
return;
}
var sLogin = message as LoginServerMessage;
if (sLogin != null)
{
if (_needInit)
{
Server = BasicTeraData.Servers.GetServer(sLogin.ServerId, Server);
_messageFactory.Version = Server.Region;
Logger.Info($"Logged in to server {Server.Name}.");
_teraData = BasicTeraData.DataForRegion(Server.Region);
_entityTracker = new EntityTracker(_teraData.NpcDatabase);
_playerTracker = new PlayerTracker(_entityTracker, BasicTeraData.Servers);
_abnormalityTracker = new AbnormalityTracker(_entityTracker, _playerTracker, _teraData.HotDotDatabase, _abnormalityStorage, CheckUpdate);
_entityTracker.Update(message);
_needInit = false;
}
_abnormalityStorage.EndAll(message.Time.Ticks);
_abnormalityTracker = new AbnormalityTracker(_entityTracker, _playerTracker, _teraData.HotDotDatabase, _abnormalityStorage, CheckUpdate);
return;
}
var cVersion = message as C_CHECK_VERSION;
if (cVersion != null)
{
var opCodeNamer =
new OpCodeNamer(Path.Combine(BasicTeraData.ResourceDirectory,
$"opcodes/{cVersion.Versions[0]}.txt"));
_messageFactory = new MessageFactory(opCodeNamer, Server.Region);
return;
}
}
public TicTacToe(PlayerTracker player_tracker, Grid grid, LineChecker line_checker)
{
_player_tracker = player_tracker;
_grid = grid;
_line_checker = line_checker;
}
private void HandleNewConnection(Server server)
{
Text = string.Format("Damage Meter connected to {0}", server.Name);
_server = server;
_teraData = _basicTeraData.DataForRegion(server.Region);
_entityTracker = new EntityTracker(_teraData.NpcDatabase);
_playerTracker = new PlayerTracker(_entityTracker);
_damageTracker = new DamageTracker();
_messageFactory = new MessageFactory(_teraData.OpCodeNamer);
Logger.Log(Text);
}
private void HandleNewConnection(Server server)
{
Text = $"Damage Meter connected to {server.Name}";
_server = server;
_teraData = BasicTeraData.DataForRegion(server.Region);
_entityRegistry = new EntityTracker();
_playerTracker = new PlayerTracker(_entityRegistry);
_damageTracker = new DamageTracker(_entityRegistry, _playerTracker, _teraData.SkillDatabase);
_messageFactory = new MessageFactory(_teraData.OpCodeNamer);
}
