public PlayerObject GetTarget(bool isRight)
{
var sortedList = new SortedList<float, PlayerObject>();
foreach (PlayerObject po in _targetList)
{
sortedList.Add(po._playerPrefab.transform.position.x, po);
}
float currentTargetX = _currentTarget._playerPrefab.transform.position.x;
foreach (var kpo in sortedList)
{
PlayerObject po = kpo.Value;
if (isRight)
{
if (currentTargetX < kpo.Key)
{
_currentTarget = po;
break;
}
}
else
{
if (currentTargetX >= kpo.Key)
{
_currentTarget = po;
break;
}
}
}
return _currentTarget;
}
public void procBonusStart(PlayerObject player)
{
if(activeBonus != null)
{
activeBonus.start(player);
}
}
// Player attacking trainer.
public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = false)
{
if (attacker == null) return 0;
if (_currentAttacker != null && _currentAttacker != attacker)
{
OutputAverage();
ResetStats();
}
damage += attacker.AttackBonus;
_currentAttacker = attacker;
_hitCount++;
_totalDamage += damage;
_lastAttackTime = Envir.Time;
switch (type)
{
case DefenceType.ACAgility:
attacker.ReceiveChat(damage + " Physical Agility Damage inflicted on the trainer.", ChatType.Trainer);
break;
case DefenceType.AC:
attacker.ReceiveChat(damage + " Physical Damage inflicted on the trainer.", ChatType.Trainer);
break;
case DefenceType.MACAgility:
attacker.ReceiveChat(damage + " Magic Agility Damage inflicted on the trainer.", ChatType.Trainer);
break;
case DefenceType.MAC:
attacker.ReceiveChat(damage + " Magic Damage inflicted on the trainer.", ChatType.Trainer);
break;
case DefenceType.Agility:
attacker.ReceiveChat(damage + " Agility Damage inflicted on the trainer.", ChatType.Trainer);
break;
}
return 1;
}
public bool CheckSkillConditions(PlayerObject origin, PlayerObject target)
{
// Check target
var targetType = TargetType.None;
Team teamOrigin = origin._playerPrefab.GetComponent<PlayerState>()._team;
Team teamTarget = target._playerPrefab.GetComponent<PlayerState>()._team;
if (origin == target)
{
targetType = TargetType.Myself;
return false;
} /*
else if ((teamOrigin == Team.Blue && teamTarget == Team.Blue) ||
(teamOrigin == Team.Red && teamTarget == Team.Red))
{
targetType = TargetType.Ally;
}
else
{
targetType = TargetType.Enemy;
}
if (_targetTypes.Find(t => t != null && t == targetType) == TargetType.None)
{
return false;
}
*/
// Check range
if (_range <= 0)
{
return true;
}
float distance = Vector3.Distance(origin._playerPrefab.position, target._playerPrefab.position);
Debug.Log("Distance: " + distance + "max range: " + _range);
if (distance > _range)
{
return false;
}
// Checks if the source is facing the target (Expensive)
if (_needToBeInFront)
{
Vector3 heading = origin._playerPrefab.transform.position - target._playerPrefab.transform.position;
float dot = Vector3.Dot(heading, origin._playerPrefab.transform.forward);
if (dot < 0.0f)
{
Debug.Log("in front");
}
else
{
Debug.Log("Not in front");
return false;
}
}
return true;
}
public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
{
int currentMoveDistance = 0;
Point target = Functions.PointMove(CurrentLocation, attacker.Direction, _ballMoveDistance);
MirDirection dir = Functions.DirectionFromPoint(CurrentLocation, target);
while (currentMoveDistance < _ballMoveDistance)
{
Point location = Functions.PointMove(CurrentLocation, dir, 1);
if (location.X < 0 || location.Y < 0 || location.X >= CurrentMap.Width || location.Y >= CurrentMap.Height) break;
currentMoveDistance++;
if (!CurrentMap.GetCell(location).Valid)
{
dir = Functions.ReverseDirection(dir);
continue;
}
Walk(dir);
MoveTime = 0;
ActionTime = 0;
}
return 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="SelectPlayerObjectEventArgs" /> class.
/// </summary>
/// <param name="player">The player.</param>
/// <param name="object">The player object.</param>
/// <param name="modelid">The modelid.</param>
/// <param name="position">The position.</param>
public SelectPlayerObjectEventArgs(BasePlayer player, PlayerObject @object, int modelid, Vector3 position)
: base(position)
{
Player = player;
Object = @object;
ModelId = modelid;
}
public void AddEffectsForPlayer(PlayerObject source, PlayerObject target, List<Effect> effect)
{
foreach (Effect e in effect)
{
DynamicEffect de = new DynamicEffect(e, source, target);
_effectDictionary[target].Add(de);
}
}
public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
{
CheckDirection();
if (!Conquest.WarIsOn || attacker.MyGuild != null && Conquest.Owner == attacker.MyGuild.Guildindex) damage = 0;
return base.Attacked(attacker, damage, type, damageWeapon);
}
/// <summary>
/// Initializes a new instance of the <see cref="EditPlayerObjectEventArgs" /> class.
/// </summary>
/// <param name="player">The player.</param>
/// <param name="object">The global object.</param>
/// <param name="response">The response.</param>
/// <param name="position">The position.</param>
/// <param name="rotation">The rotation.</param>
public EditPlayerObjectEventArgs(GtaPlayer player, PlayerObject @object, EditObjectResponse response,
Vector3 position, Vector3 rotation)
: base(position)
{
Player = player;
Object = @object;
EditObjectResponse = response;
Rotation = rotation;
}
public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
{
if (ChildRock) ParentRock.FirstAttack = false;
if (!ChildRock && FirstAttack == true)
{
Die();
return 0;
}
return base.Attacked(attacker, damage, type, damageWeapon);
}
public void procBonusEnd(PlayerObject player)
{
if(activeBonus != null)
{
activeBonus.end(player);
if(activeBonus.isEnd())
activeBonus = null;
}
}
void Start()
{
_parent = this.transform.parent.gameObject;
_parentPlayerObj = _parent.GetComponent<PlayerObject>();
_hp = this.transform.Find("Panel").Find("slider_hp").GetComponent<Slider>();
_time = this.transform.Find("Panel").Find("slider_time").GetComponent<Slider>();
_name = this.transform.Find("Panel").Find("txt_enemyname").GetComponent<Text>();
_icon = this.transform.Find("Panel").Find("img_icon").GetComponent<RawImage>();
if (_name != null) _name.text = _parent.name;
if (_time != null) _time.maxValue = _parentPlayerObj.waitTime;
}
/// <summary>
/// Registers a player entity with this player mover.
/// </summary>
/// <param name="player">The player to register with this mover.</param>
public void RegisterPlayer(PlayerObject player)
{
if(OnRegisterPlayer(player))
{
m_registeredPlayers.Add(player);
if (player.Player.isLocal)
OnRegistered();
else
photonView.RPC(nameof(_rpcOnRegistered), player.Player);
}
}
public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
{
MirDirection newDirection = (MirDirection)(3 - GetDamageLevel());
if (newDirection != Direction)
{
Direction = newDirection;
Broadcast(new S.ObjectTurn { ObjectID = ObjectID, Direction = Direction, Location = CurrentLocation });
}
return base.Attacked(attacker, damage, type, damageWeapon);
}
void Awake()
{
// Setting up the references.
settings = GameObject.Find("System");
player = settings.GetComponent<SystemDB>().player;
playerObject = GameObject.FindGameObjectWithTag("Player").GetComponent<PlayerObject>();
playerMovement = GetComponent<PlayerMovement>();
lastPlayerSighting = GameObject.FindGameObjectWithTag("GameController").GetComponent<LastPlayerSighting>();
health=player.maxHP;
player.HP = health;
}
public override bool Harvest(PlayerObject player)
{
if (RemainingSkinCount == 0)
{
for (int i = _drops.Count - 1; i >= 0; i--)
if (player.CanGainItem(_drops[i]))
{
player.GainItem(_drops[i]);
_drops.RemoveAt(i);
}
if (_drops.Count == 0)
{
Harvested = true;
_drops = null;
Broadcast(new S.ObjectHarvested { ObjectID = ObjectID, Direction = Direction, Location = CurrentLocation });
}
else player.ReceiveChat("You cannot carry anymore.", ChatType.System);
return true;
}
if (--RemainingSkinCount > 0) return true;
_drops = new List<UserItem>();
for (int i = 0; i < Info.Drops.Count; i++)
{
DropInfo drop = Info.Drops[i];
int rate = (int)(drop.Chance / Settings.DropRate); if (rate < 1) rate = 1;
if (drop.Gold > 0 || Envir.Random.Next(rate) != 0) continue;
UserItem item = Envir.CreateDropItem(drop.Item);
if (item == null) continue;
if (item.Info.Type == ItemType.Meat)
item.CurrentDura = (ushort)Math.Max(0, item.CurrentDura + Quality);
_drops.Add(item);
}
if (_drops.Count == 0)
{
player.ReceiveChat("Nothing was found.", ChatType.System);
Harvested = true;
_drops = null;
Broadcast(new S.ObjectHarvested { ObjectID = ObjectID, Direction = Direction, Location = CurrentLocation });
}
return true;
}
void UpdateHumanoid(PlayerObject _p)
{
if (_p.state == PlayerObject.PlayerState.Dead) return;
if (_p._target != null) _p._lookAt = _p._target.transform.position;
this.transform.LookAt(_p._lookAt);
switch (_p.type)
{
case PlayerObject.PlayerType.EnemyRootedAI:
_p.RootedMovement();
break;
case PlayerObject.PlayerType.EnemyAI:
_p.AiMovement();
break;
}
}
public override void Start()
{
base.Start();
questions = new QuestionDictionary();
questions.loadList("plant");
print(questions.QuestionList.Count);
_questionList = questions.QuestionList;
_pObject = FnGlobal.GetPlayer<PlayerObject>();
if (_pObject.type == PlayerObject.PlayerType.Player)
{
AnswerResult = Instantiate(AnswerResult) as GameObject;
AnswerResult.GetComponent<CanvasGroup>().alpha = 0;
AnswerResult.SetActive(false);
}
_victoryCanvas = Instantiate(_victoryCanvas) as GameObject;
_victoryCanvas.SetActive(false);
}
// Player attacking trainer.
public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = false)
{
if (attacker == null) return 0;
if (_currentAttacker != null && _currentAttacker != attacker)
{
OutputAverage();
ResetStats();
}
damage += attacker.AttackBonus;
int armour = 0;
//deal with trainers defense
switch (type)
{
case DefenceType.AC:
case DefenceType.ACAgility:
armour = GetAttackPower(MinAC, MaxAC);
break;
case DefenceType.MAC:
case DefenceType.MACAgility:
armour = GetAttackPower(MinMAC, MaxMAC);
break;
}
if (armour >= damage)
{
BroadcastDamageIndicator(DamageType.Miss);
return 0;
}
damage -= armour;
if (_currentAttacker == null)
_StartTime = Envir.Time;
_currentAttacker = attacker;
_hitCount++;
_totalDamage += damage;
_lastAttackTime = Envir.Time;
ReportDamage(damage, type, false);
return 1;
}
// Player attacking trainer.
public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = false)
{
switch (type)
{
case DefenceType.ACAgility:
attacker.ReceiveChat(damage + " AC Agility Damage inflicted on the trainer.", ChatType.Trainer);
break;
case DefenceType.AC:
attacker.ReceiveChat(damage + " AC Damage inflicted on the trainer.", ChatType.Trainer);
break;
case DefenceType.MACAgility:
attacker.ReceiveChat(damage + " MAC Agility Damage inflicted on the trainer.", ChatType.Trainer);
break;
case DefenceType.MAC:
attacker.ReceiveChat(damage + " MAC Damage inflicted on the trainer.", ChatType.Trainer);
break;
case DefenceType.Agility:
attacker.ReceiveChat(damage + " Agility Damage inflicted on the trainer.", ChatType.Trainer);
break;
}
return 1;
}
public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
{
if (DragonLink)
{
if (Envir.DragonSystem.LinkedMonster != null)
{
MonsterObject ob = Envir.DragonSystem.LinkedMonster;
if (ob.EXPOwner == null || ob.EXPOwner.Dead)
ob.EXPOwner = attacker;
if (ob.EXPOwner == attacker)
ob.EXPOwnerTime = Envir.Time + EXPOwnerDelay;
}
if (damageWeapon)
attacker.DamageWeapon();
Envir.DragonSystem.GainExp(Envir.Random.Next(1, 50));
return 1;
}
return 0;
}
public DynamicEffect(Effect effect, PlayerObject source, PlayerObject target)
{
_frequentDuration = _currentDuration = effect._duration;
_frequency = effect._frequency;
_amount = effect._amount;
_percentage = effect._percentage;
_effectType = effect._type;
_target = target;
_source = source;
if (_currentDuration == 0.0f)
{
_dynamicType = DynamicEffectType.instant;
}
else if (_currentDuration > 0.0f && _frequency <= 0.0f)
{
_dynamicType = DynamicEffectType.buff;
}
else if (_currentDuration > 0.0f && _frequency > 0.0f)
{
_dynamicType = DynamicEffectType.frequent;
}
}
void ManageQuestion(PlayerObject.TurnStatus _turnStatus)
{
switch (_turnStatus)
{
case PlayerObject.TurnStatus.Answering:
if (_currentQuestion == null)
{
int index = rand.Next(0, _questionList.Count - 1);
_currentQuestion = _questionList[index];
_questionList.RemoveAt(index);
_countQuestionAnswered += 1;
}
break;
case PlayerObject.TurnStatus.QuestionBreakInteract:
if (_currentQuestion == null)
{
int index = rand.Next(0, _questionList.Count - 1);
_currentQuestion = _questionList[index];
_questionList.RemoveAt(index);
_countQuestionAnswered += 1;
}
break;
}
}
public void SetOwner(PlayerObject owner)
{
player = owner;
name = player.playerName.ToString();
}
/// <summary>
/// Registers types this PlayerObjectController requires the system to use.
/// </summary>
public virtual void RegisterTypes()
{
PlayerObject.Register <PlayerObject>();
}
public override bool IsAttackTarget(PlayerObject attacker)
{
return(!Sleeping && base.IsAttackTarget(attacker));
}
private void InitializeDB()
{
if (!PlayerObject.Contains("Moderator"))
{
PlayerObject.Set("Moderator", false);
}
moderator = PlayerObject.GetBool("Moderator");
if (!PlayerObject.Contains("HidePremium"))
{
PlayerObject.Set("HidePremium", false);
}
hidePremium = PlayerObject.GetBool("HidePremium");
if (!PlayerObject.Contains("Level"))
{
PlayerObject.Set("Level", 1);
}
level = PlayerObject.GetInt("Level");
if (!PlayerObject.Contains("TotalXP"))
{
PlayerObject.Set("TotalXP", 0);
}
totalXP = PlayerObject.GetInt("TotalXP");
if (!PlayerObject.Contains("XP"))
{
PlayerObject.Set("XP", 0);
}
xp = PlayerObject.GetInt("XP");
if (!PlayerObject.Contains("TotalXPOld"))
{
PlayerObject.Set("TotalXPOld", totalXP);
PlayerObject.Set("TotalXP", Player.getXPToLevel(level - 1) + xp);
}
if (!PlayerObject.Contains("Shards"))
{
PlayerObject.Set("Shards", 0);
}
shards = PlayerObject.GetInt("Shards");
if (!PlayerObject.Contains("Race"))
{
PlayerObject.Set("Race", 0);
}
race = PlayerObject.GetInt("Race");
if (!PlayerObject.Contains("AttackBoosts"))
{
PlayerObject.Set("AttackBoosts", 10);
}
attackBoostsTotal = PlayerObject.GetInt("AttackBoosts");
if (!PlayerObject.Contains("DefenseBoosts"))
{
PlayerObject.Set("DefenseBoosts", 10);
}
defenseBoostsTotal = PlayerObject.GetInt("DefenseBoosts");
if (!PlayerObject.Contains("Background"))
{
PlayerObject.Set("Background", 0);
}
background = PlayerObject.GetInt("Background");
//if (!PlayerObject.Contains("Premium")) PlayerObject.Set("Premium", false);
//else isPremium = PlayerObject.GetBool("Premium");
if (!PlayerObject.Contains("PremiumUntil"))
{
PlayerObject.Set("PremiumUntil", new DateTime(2000, 1, 1, 0, 0, 0));
}
if (!PlayerObject.Contains("Banned"))
{
PlayerObject.Set("Banned", false);
}
banned = PlayerObject.GetBool("Banned");
if (!PlayerObject.Contains("BannedReason"))
{
PlayerObject.Set("BannedReason", "");
}
bannedReason = PlayerObject.GetString("BannedReason");
if (!PlayerObject.Contains("BannedUntil"))
{
PlayerObject.Set("BannedUntil", new DateTime(2000, 1, 1, 0, 0, 0));
}
banned |= (PlayerObject.GetDateTime("BannedUntil") - DateTime.Now).Seconds > 0;
if (!PlayerObject.Contains("BanHistory"))
{
PlayerObject.Set("BanHistory", new DatabaseArray());
}
if (!PlayerObject.Contains("WarnHistory"))
{
PlayerObject.Set("WarnHistory", new DatabaseArray());
}
if (!PlayerObject.Contains("FBInvites"))
{
PlayerObject.Set("FBInvites", new DatabaseArray());
}
// editor
if (!PlayerObject.Contains("EditorSlots"))
{
PlayerObject.Set("EditorSlots", 3);
}
mapSlots = PlayerObject.GetInt("EditorSlots");
if (!PlayerObject.Contains("Maps"))
{
PlayerObject.Set("Maps", new DatabaseArray());
}
if (!PlayerObject.Contains("LastPlayedMaps"))
{
PlayerObject.Set("LastPlayedMaps", new DatabaseArray());
}
if (!PlayerObject.Contains("LikedMaps"))
{
PlayerObject.Set("LikedMaps", new DatabaseArray());
}
if (!PlayerObject.Contains("DislikedMaps"))
{
PlayerObject.Set("DislikedMaps", new DatabaseArray());
}
// stats
DatabaseObject stats = null;
if (PlayerObject.Contains("Stats"))
{
stats = PlayerObject.GetObject("Stats");
}
if (stats == null)
{
stats = new DatabaseObject();
}
//String key;
// size
/*for (int i = 0; i < 5; ++i) {
* // battle type
* for (int j = 0; j < 4; ++j) {
* // start type
* for (int k = 0; k < 2; ++k) {
* key = "Matches_" + i + "_" + j + "_" + k;
* if (!stats.Contains(key)) stats.Set(key, 0);
* key = "Wins_" + i + "_" + j + "_" + k;
* if (!stats.Contains(key)) stats.Set(key, 0);
* //key = "Finished_" + i + "_" + j + "_" + k;
* //if (!stats.Contains(key)) stats.Set(key, 0);
* }
* }
* }*/
if (!stats.Contains("RegionsConquered"))
{
stats.Set("RegionsConquered", 0);
}
if (!stats.Contains("RegionsLost"))
{
stats.Set("RegionsLost", 0);
}
if (!stats.Contains("FightWinRatio"))
{
stats.Set("FightWinRatio", 0.0f);
}
if (!stats.Contains("FightCount"))
{
stats.Set("FightCount", 0);
}
if (!stats.Contains("GameDurationTotal"))
{
stats.Set("GameDurationTotal", 0);
}
if (!stats.Contains("GameDurationAverage"))
{
stats.Set("GameDurationAverage", 0.0f);
}
if (!stats.Contains("AveragePlayerCount"))
{
stats.Set("AveragePlayerCount", 0.0f);
}
if (!stats.Contains("PlayersEliminated"))
{
stats.Set("PlayersEliminated", 0);
}
if (!stats.Contains("Wins6Plus"))
{
stats.Set("Wins6Plus", 0);
}
if (!stats.Contains("ConsecutiveRollWins"))
{
stats.Set("ConsecutiveRollWins", 0);
}
// races
for (int i = 0; i < 8; ++i)
{
//if (!stats.Contains("RaceMatches_" + i)) stats.Set("RaceMatches_" + i, 0);
if (!stats.Contains("RaceWins_" + i))
{
stats.Set("RaceWins_" + i, 0);
}
}
for (int i = 100; i < 124; i++)
{
//if (!stats.Contains("RaceMatches_" + i)) stats.Set("RaceMatches_" + i, 0);
if (!stats.Contains("RaceWins_" + i))
{
stats.Set("RaceWins_" + i, 0);
}
}
if (!stats.Contains("TotalMatches"))
{
stats.Set("TotalMatches", 0);
}
if (!stats.Contains("TotalWins"))
{
stats.Set("TotalWins", 0);
}
if (!stats.Contains("TotalFinished"))
{
stats.Set("TotalFinished", 0);
}
if (!PlayerObject.Contains("Stats"))
{
PlayerObject.Set("Stats", stats);
}
// achievements
//DatabaseObject achievements = null;
if (PlayerObject.Contains("Achievements"))
{
achievements = PlayerObject.GetObject("Achievements");
}
if (achievements == null)
{
achievements = new DatabaseObject();
}
//
if (!PlayerObject.Contains("Achievements"))
{
PlayerObject.Set("Achievements", achievements);
}
// award shards if we didn't do it before
if (!PlayerObject.Contains("ShardsAwarded"))
{
PlayerObject.Set("Shards", shards + stats.GetInt("RegionsConquered"));
PlayerObject.Set("ShardsAwarded", true);
}
// when did we awarded shards for visit last time?
if (!PlayerObject.Contains("LastShardsReward"))
{
PlayerObject.Set("LastShardsReward", new DateTime(2000, 1, 1, 0, 0, 0));
}
if (!PlayerObject.Contains("ConsecutiveVisits"))
{
PlayerObject.Set("ConsecutiveVisits", 0);
}
// ranking
if (!PlayerObject.Contains("RankingRating"))
{
PlayerObject.Set("RankingRating", 1500.0f);
}
try {
rankingNew = rankingOriginal = PlayerObject.GetFloat("RankingRating");
}
catch (Exception e) {
rankingNew = rankingOriginal = (float)PlayerObject.GetInt("RankingRating");
}
if (rankingNew < 0)
{
rankingNew = rankingOriginal = 1500.0f;
PlayerObject.Set("RankingRating", 1500.0f);
}
if (!PlayerObject.Contains("RankingDeviation"))
{
PlayerObject.Set("RankingDeviation", 100.0f);
}
rankingDeviation = PlayerObject.GetFloat("RankingDeviation");
if (!PlayerObject.Contains("RankingVolatility"))
{
PlayerObject.Set("RankingVolatility", 0.06f);
}
rankingVolatility = PlayerObject.GetFloat("RankingVolatility");
if (float.IsNaN(rankingDeviation) || float.IsNaN(rankingVolatility) || float.IsInfinity(rankingDeviation) || float.IsInfinity(rankingVolatility) ||
rankingDeviation > 1000 || rankingVolatility > 1)
{
rankingDeviation = 350.0f;
PlayerObject.Set("RankingDeviation", 350.0f);
rankingVolatility = 0.06f;
PlayerObject.Set("RankingVolatility", 0.06f);
rankingNew = rankingOriginal = 1500.0f;
PlayerObject.Set("RankingRating", 1500.0f);
}
rankingDeviationGS = rankingDeviation / 173.7178f;
rankingGS = (rankingOriginal - 1500) / 173.7178f;
// player presence
if (!PlayerObject.Contains("RoomName"))
{
PlayerObject.Set("RoomName", "");
}
if (!PlayerObject.Contains("RoomId"))
{
PlayerObject.Set("RoomId", "");
}
if (!PlayerObject.Contains("PresenceStatus"))
{
PlayerObject.Set("PresenceStatus", 0);
}
if (!PlayerObject.Contains("LastSeenOnline"))
{
PlayerObject.Set("LastSeenOnline", DateTime.Now);
}
//social
if (!PlayerObject.Contains("Friends"))
{
PlayerObject.Set("Friends", new DatabaseArray());
}
if (!PlayerObject.Contains("Blacklist"))
{
PlayerObject.Set("Blacklist", new DatabaseArray());
}
if (!PlayerObject.Contains("PublicProfile"))
{
PlayerObject.Set("PublicProfile", true);
}
PlayerObject.Save(savingFinished);
}
// Use this for initialization
void Start()
{
ourLauncher = GameObject.Find("LaunchContainer");
ourPlayer = ourLauncher.GetComponent<PlayerObject>();
defaultObject = GameObject.Find("LevelHandler");
ourLevelManager = defaultObject.GetComponent<LevelManager>();
Projectile = GameObject.Find("Cone Projectile");
OurCamera = GameObject.Find("Main Camera");
_pointCamera = GameObject.Find("Point Camera");
_defaultCamera = OurCamera;
DefaultCameraSetting();
PHInit();
}
public override bool IsAttackTarget(PlayerObject attacker)
{
return(Parent.IsAttackTarget(attacker));
}
private void CpDialog_Response(object sender, SampSharp.GameMode.Events.DialogResponseEventArgs e)
{
if (e.Player.Equals(player))
{
if (e.DialogButton == DialogButton.Left)
{
Checkpoint cp = editingRace.checkpoints[checkpointIndex];
switch (e.ListItem)
{
case 0: // Edit checkpoint position
{
if (moverObject == null)
{
moverObject = new PlayerObject(
player,
moverObjectModelID,
cp.Position + moverObjectOffset,
new Vector3(0.0, 0.0, 0.0));
moverObject.Edit();
moverObject.Edited += moverObject_Edited;
}
else
{
moverObject.Position = cp.Position;
moverObject.Edit();
}
break;
}
case 1: // Edit checkpoint size
{
InputDialog cpSizeDialog = new InputDialog("Checkpoint size", "Current size: " + cp.Size.ToString(), false, "Set", "Cancel");
cpSizeDialog.Show(player);
cpSizeDialog.Response += CpSizeDialog_Response;
break;
}
case 2: // Change checkpoint type
{ // TODO: A corriger, ne fonctionne pas
if (e.ListItem == 0) // To Air
{
if (cp.Type == CheckpointType.Normal)
{
editingRace.checkpoints[checkpointIndex].Type = CheckpointType.Air;
}
else if (cp.Type == CheckpointType.Finish)
{
editingRace.checkpoints[checkpointIndex].Type = CheckpointType.AirFinish;
}
UpdatePlayerCheckpoint();
player.Notificate("Updated");
ShowCheckpointDialog();
break;
}
if (e.ListItem == 1) // To Normal
{
if (cp.Type == CheckpointType.Air)
{
cp.Type = CheckpointType.Normal;
}
else if (cp.Type == CheckpointType.AirFinish)
{
cp.Type = CheckpointType.Finish;
}
UpdatePlayerCheckpoint();
player.Notificate("Updated");
ShowCheckpointDialog();
break;
}
break;
}
case 3: // Edit events
{
ShowCheckpointEventDialog();
break;
}
}
}
}
}
public void CallDefaultNPC(DefaultNPCType type, PlayerObject player, params object[] value)
{
string key = string.Empty;
switch (type)
{
case DefaultNPCType.Login:
key = "Login";
break;
case DefaultNPCType.UseItem:
if (value.Length < 1)
{
return;
}
key = string.Format("UseItem({0})", value[0]);
break;
case DefaultNPCType.Trigger:
if (value.Length < 1)
{
return;
}
key = string.Format("Trigger({0})", value[0]);
break;
case DefaultNPCType.MapCoord:
if (value.Length < 3)
{
return;
}
key = string.Format("MapCoord({0},{1},{2})", value[0], value[1], value[2]);
break;
case DefaultNPCType.MapEnter:
if (value.Length < 1)
{
return;
}
key = string.Format("MapEnter({0})", value[0]);
break;
case DefaultNPCType.Die:
key = "Die";
break;
case DefaultNPCType.LevelUp:
key = "LevelUp";
break;
case DefaultNPCType.CustomCommand:
if (value.Length < 1)
{
return;
}
key = string.Format("CustomCommand({0})", value[0]);
break;
case DefaultNPCType.OnAcceptQuest:
if (value.Length < 1)
{
return;
}
key = string.Format("OnAcceptQuest({0})", value[0]);
break;
case DefaultNPCType.OnFinishQuest:
if (value.Length < 1)
{
return;
}
key = string.Format("OnFinishQuest({0})", value[0]);
break;
case DefaultNPCType.Daily:
key = "Daily";
player.Info.NewDay = false;
break;
case DefaultNPCType.TalkMonster:
if (value.Length < 1)
{
return;
}
key = string.Format("TalkMonster({0})", value[0]);
break;
case DefaultNPCType.EventReward:
key = "EventReward";
break;
}
key = string.Format("[@_{0}]", key);
if (player == null)
{
return;
}
DelayedAction action = new DelayedAction(DelayedType.NPC, Envir.Time + 1, DefaultNPC.ObjectID, key);
player.ActionList.Add(action);
player.Enqueue(new S.NPCUpdate {
NPCID = DefaultNPC.ObjectID
});
}
// Pet attacking trainer.
public override int Attacked(MonsterObject attacker, int damage, DefenceType type = DefenceType.ACAgility)
{
if (attacker == null || attacker.Master == null)
{
return(0);
}
if (_currentAttacker != null && _currentAttacker != attacker.Master)
{
OutputAverage();
ResetStats();
}
int armour = 0;
//deal with trainers defense
switch (type)
{
case DefenceType.AC:
case DefenceType.ACAgility:
armour = GetAttackPower(Stats[Stat.MinAC], Stats[Stat.MaxAC]);
break;
case DefenceType.MAC:
case DefenceType.MACAgility:
armour = GetAttackPower(Stats[Stat.MinMAC], Stats[Stat.MaxMAC]);
break;
}
if (armour >= damage)
{
BroadcastDamageIndicator(DamageType.Miss);
return(0);
}
damage -= armour;
if (_currentAttacker == null)
{
_StartTime = Envir.Time;
}
MapObject tmpAttacker = attacker.Master;
while (true)
{
if (tmpAttacker.Master != null)
{
tmpAttacker = tmpAttacker.Master;
continue;
}
break;
}
_currentAttacker = (PlayerObject)tmpAttacker;
_hitCount++;
_totalDamage += damage;
_lastAttackTime = Envir.Time;
ReportDamage(damage, type, true);
return(1);
}
private void Start()
{
freezePosition = false;
player = (PlayerObject)GameObject.FindGameObjectWithTag("Player").GetComponent(typeof(PlayerObject));
respawn();
}
public void playerGotOffline()
{
PlayerObject.Set("PresenceStatus", 0);
PlayerObject.Set("LastSeenOnline", DateTime.Now);
savePlayerData();
}
private void Awake()
{
SelfPlayerAcceleration = GetComponentInParent <PlayerAcceleration>();
SelfPlayerObject = GetComponentInChildren <PlayerObject>();
}
// Use this for initialization
void Start()
{
requiredToStart = GameManager.Instance.requiredPlayers;
if (GameManager.Instance.type == MyGameType.Private)
{
requiredToStart = 2;
}
PhotonNetwork.RaiseEvent((int)EnumPhoton.ReadyToPlay, 0, true, null);
// LUDO
// Rotate board and set colors
int rotation = UnityEngine.Random.Range(0, 4);
Color[] colors = null;
if (rotation == 0)
{
colors = new Color[] { colorYellow, colorGreen, colorRed, colorBlue };
}
else if (rotation == 1)
{
colors = new Color[] { colorBlue, colorYellow, colorGreen, colorRed };
ludoBoard.GetComponent <RectTransform>().eulerAngles = new Vector3(0, 0, -90.0f);
}
else if (rotation == 2)
{
colors = new Color[] { colorRed, colorBlue, colorYellow, colorGreen };
ludoBoard.GetComponent <RectTransform>().eulerAngles = new Vector3(0, 0, -180.0f);
}
else
{
colors = new Color[] { colorGreen, colorRed, colorBlue, colorYellow };
ludoBoard.GetComponent <RectTransform>().eulerAngles = new Vector3(0, 0, -270.0f);
}
for (int i = 0; i < diceBackgrounds.Length; i++)
{
diceBackgrounds[i].GetComponent <Image>().color = colors[i];
}
for (int i = 0; i < playersPawnsColors.Length; i++)
{
for (int j = 0; j < playersPawnsColors[i].objectsArray.Length; j++)
{
playersPawnsColors[i].objectsArray[j].GetComponent <Image>().color = colors[i];
playersPawnsMultiple[i].objectsArray[j].GetComponent <Image>().color = colors[i];
}
}
// END LUDO
// Update player data in playfab
Dictionary <string, string> data = new Dictionary <string, string>();
data.Add(MyPlayerData.CoinsKey, (GameManager.Instance.myPlayerData.GetCoins() - GameManager.Instance.payoutCoins).ToString());
data.Add(MyPlayerData.GamesPlayedKey, (GameManager.Instance.myPlayerData.GetPlayedGamesCount() + 1).ToString());
GameManager.Instance.myPlayerData.UpdateUserData(data);
currentPlayerIndex = 0;
emojiSprites = GameObject.Find("StaticGameVariablesContainer").GetComponent <StaticGameVariablesController>().emoji;
myId = GameManager.Instance.playfabManager.PlayFabId;
playerObjects = new List <PlayerObject>();
avatars = GameManager.Instance.opponentsAvatars;
avatars.Insert(0, GameManager.Instance.avatarMy);
names = GameManager.Instance.opponentsNames;
names.Insert(0, GameManager.Instance.nameMy);
PlayersIDs = new List <string>();
for (int i = 0; i < GameManager.Instance.opponentsIDs.Count; i++)
{
if (GameManager.Instance.opponentsIDs[i] != null)
{
PlayersIDs.Add(GameManager.Instance.opponentsIDs[i]);
}
}
PlayersIDs.Insert(0, GameManager.Instance.playfabManager.PlayFabId);
for (int i = 0; i < PlayersIDs.Count; i++)
{
playerObjects.Add(new PlayerObject(names[i], PlayersIDs[i], avatars[i]));
}
// Bubble sort
for (int i = 0; i < PlayersIDs.Count; i++)
{
for (int j = 0; j < PlayersIDs.Count - 1; j++)
{
if (string.Compare(playerObjects[j].id, playerObjects[j + 1].id) == 1)
{
// swaap ids
PlayerObject temp = playerObjects[j + 1];
playerObjects[j + 1] = playerObjects[j];
playerObjects[j] = temp;
}
}
}
for (int i = 0; i < PlayersIDs.Count; i++)
{
Debug.Log(playerObjects[i].id);
}
ActivePlayersInRoom = PlayersIDs.Count;
if (PlayersIDs.Count == 2)
{
if (SecondPlayerOnDiagonal)
{
Players[1].SetActive(false);
Players[3].SetActive(false);
ActivePlayers = new GameObject[2];
ActivePlayers[0] = Players[0];
ActivePlayers[1] = Players[2];
// LUDO
for (int i = 0; i < PlayersPawns[1].objectsArray.Length; i++)
{
PlayersPawns[1].objectsArray[i].SetActive(false);
}
for (int i = 0; i < PlayersPawns[3].objectsArray.Length; i++)
{
PlayersPawns[3].objectsArray[i].SetActive(false);
}
// END LUDO
}
else
{
// LUDO
for (int i = 0; i < PlayersPawns[21].objectsArray.Length; i++)
{
PlayersPawns[2].objectsArray[i].SetActive(false);
}
for (int i = 0; i < PlayersPawns[3].objectsArray.Length; i++)
{
PlayersPawns[3].objectsArray[i].SetActive(false);
}
// END LUDO
Players[2].SetActive(false);
Players[3].SetActive(false);
ActivePlayers = new GameObject[2];
ActivePlayers[0] = Players[0];
ActivePlayers[1] = Players[1];
}
}
else
{
ActivePlayers = Players;
}
int startPos = 0;
for (int i = 0; i < playerObjects.Count; i++)
{
if (playerObjects[i].id == GameManager.Instance.playfabManager.PlayFabId)
{
startPos = i;
break;
}
}
int index = 0;
bool addedMe = false;
myIndex = startPos;
GameManager.Instance.myPlayerIndex = myIndex;
for (int i = startPos; ;)
{
if (i == startPos && addedMe)
{
break;
}
if (PlayersIDs.Count == 2 && SecondPlayerOnDiagonal)
{
if (addedMe)
{
playerObjects[i].timer = PlayersTimers[2];
playerObjects[i].ChatBubble = PlayersChatBubbles[2];
playerObjects[i].ChatBubbleText = PlayersChatBubblesText[2];
playerObjects[i].ChatbubbleImage = PlayersChatBubblesImage[2];
string id = playerObjects[i].id;
PlayersAvatarsButton[2].GetComponent <Button>().onClick.RemoveAllListeners();
PlayersAvatarsButton[2].GetComponent <Button>().onClick.AddListener(() => ButtonClick(id));
// LUDO
playerObjects[i].dice = PlayersDices[2];
playerObjects[i].pawns = PlayersPawns[2].objectsArray;
for (int k = 0; k < playerObjects[i].pawns.Length; k++)
{
playerObjects[i].pawns[k].GetComponent <LudoPawnController>().setPlayerIndex(i);
}
playerObjects[i].homeLockObjects = HomeLockObjects[2];
// END LUDO
}
else
{
GameManager.Instance.myPlayerIndex = i;
playerObjects[i].timer = PlayersTimers[index];
playerObjects[i].ChatBubble = PlayersChatBubbles[index];
playerObjects[i].ChatBubbleText = PlayersChatBubblesText[index];
playerObjects[i].ChatbubbleImage = PlayersChatBubblesImage[index];
string id = playerObjects[i].id;
// LUDO
playerObjects[i].dice = PlayersDices[index];
playerObjects[i].pawns = PlayersPawns[index].objectsArray;
for (int k = 0; k < playerObjects[i].pawns.Length; k++)
{
playerObjects[i].pawns[k].GetComponent <LudoPawnController>().setPlayerIndex(i);
}
playerObjects[i].homeLockObjects = HomeLockObjects[index];
// END LUDO
}
}
else
{
playerObjects[i].timer = PlayersTimers[index];
playerObjects[i].ChatBubble = PlayersChatBubbles[index];
playerObjects[i].ChatBubbleText = PlayersChatBubblesText[index];
playerObjects[i].ChatbubbleImage = PlayersChatBubblesImage[index];
// LUDO
playerObjects[i].dice = PlayersDices[index];
playerObjects[i].pawns = PlayersPawns[index].objectsArray;
for (int k = 0; k < playerObjects[i].pawns.Length; k++)
{
playerObjects[i].pawns[k].GetComponent <LudoPawnController>().setPlayerIndex(i);
}
playerObjects[i].homeLockObjects = HomeLockObjects[index];
// END LUDO
string id = playerObjects[i].id;
if (index != 0)
{
PlayersAvatarsButton[index].GetComponent <Button>().onClick.RemoveAllListeners();
PlayersAvatarsButton[index].GetComponent <Button>().onClick.AddListener(() => ButtonClick(id));
}
}
playerObjects[i].AvatarObject = ActivePlayers[index];
ActivePlayers[index].GetComponent <PlayerAvatarController>().Name.GetComponent <Text>().text = playerObjects[i].name;
if (playerObjects[i].avatar != null)
{
ActivePlayers[index].GetComponent <PlayerAvatarController>().Avatar.GetComponent <Image>().sprite = playerObjects[i].avatar;
}
index++;
if (i < PlayersIDs.Count - 1)
{
i++;
}
else
{
i = 0;
}
addedMe = true;
}
currentPlayerIndex = GameManager.Instance.firstPlayerInGame;
GameManager.Instance.currentPlayer = playerObjects[currentPlayerIndex];
// SetTurn();
// // if (myIndex == 0)
// // {
// // SetMyTurn();
// // playerObjects[0].dice.GetComponent<GameDiceController>().DisableDiceShadow();
// // }
// // else
// // {
// // SetOpponentTurn();
// // playerObjects[currentPlayerIndex].dice.GetComponent<GameDiceController>().DisableDiceShadow();
// // }
GameManager.Instance.playerObjects = playerObjects;
// // Check if all players are still in room - if not deactivate
// for (int i = 0; i < playerObjects.Count; i++)
// {
// bool contains = false;
// if (!playerObjects[i].id.Contains("_BOT"))
// {
// for (int j = 0; j < PhotonNetwork.playerList.Length; j++)
// {
// if (PhotonNetwork.playerList[j].NickName.Equals(playerObjects[i].id))
// {
// contains = true;
// break;
// }
// }
// if (!contains)
// {
// setPlayerDisconnected(i);
// }
// }
// }
// CheckPlayersIfShouldFinishGame();
// Set prizes.
// For 2 players 1st get 2x payout and 2nd 0.
// For 4 players 1st get 4x payout and 2nd gets payout
if (ActivePlayersInRoom == 2)
{
firstPlacePrize = 2 * GameManager.Instance.payoutCoins;
secondPlacePrize = 0;
}
else if (ActivePlayersInRoom == 3)
{
firstPlacePrize = 2 * GameManager.Instance.payoutCoins;
secondPlacePrize = GameManager.Instance.payoutCoins;
}
else if (ActivePlayersInRoom == 4)
{
firstPlacePrize = 3 * GameManager.Instance.payoutCoins;
secondPlacePrize = GameManager.Instance.payoutCoins;
}
else
{
firstPlacePrize = GameManager.Instance.payoutCoins;
}
firstPrizeText.GetComponent <Text>().text = firstPlacePrize + "";
secondPrizeText.GetComponent <Text>().text = secondPlacePrize + "";
if (secondPlacePrize == 0)
{
SecondPrizeObject.SetActive(false);
firstPrizeObject.GetComponent <RectTransform>().anchoredPosition = SecondPrizeObject.GetComponent <RectTransform>().anchoredPosition;
}
// LUDO
// Enable home locks
if (GameManager.Instance.mode == MyGameMode.Quick || GameManager.Instance.mode == MyGameMode.Master)
{
for (int i = 0; i < GameManager.Instance.playerObjects.Count; i++)
{
GameManager.Instance.playerObjects[i].homeLockObjects.SetActive(true);
}
GameManager.Instance.needToKillOpponentToEnterHome = true;
}
else
{
GameManager.Instance.needToKillOpponentToEnterHome = false;
}
//GameManager.Instance.needToKillOpponentToEnterHome = false;
// END LUDO
for (int i = 0; i < playerObjects.Count; i++)
{
if (playerObjects[i].id.Contains("_BOT"))
{
GameManager.Instance.readyPlayersCount++;
}
}
GameManager.Instance.playerObjects = playerObjects;
// Check if all players are still in room - if not deactivate
for (int i = 0; i < playerObjects.Count; i++)
{
bool contains = false;
if (!playerObjects[i].id.Contains("_BOT"))
{
for (int j = 0; j < PhotonNetwork.playerList.Length; j++)
{
if (PhotonNetwork.playerList[j].NickName.Equals(playerObjects[i].id))
{
contains = true;
break;
}
}
if (!contains)
{
GameManager.Instance.readyPlayersCount++;
Debug.Log("Ready players: " + GameManager.Instance.readyPlayersCount);
setPlayerDisconnected(i);
}
}
}
CheckPlayersIfShouldFinishGame();
StartCoroutine(waitForPlayersToStart());
}
public override void goNext(PlayerObject playerObject)
{
playerObject.SetState(this);
}
public override async void Handle(CollisionStrategy collisionStrategy, PlayerObject playerObject, string elementId)
{
await collisionStrategy.ActionAsync(playerObject, elementId);
goNext(playerObject);
}
public void addLastPlayedMap(String mapKey)
{
if (isGuest)
{
return;
}
DatabaseArray maps = PlayerObject.GetArray("LastPlayedMaps");
DatabaseObject mapEntry = null;
DatabaseObject oldestEntry = null;
int oldestIndex = 0;
for (int i = 0; i < maps.Count; ++i)
{
DatabaseObject entry = maps.GetObject(i.ToString());
if (entry.Contains("Map"))
{
if (entry.GetString("Map") == mapKey)
{
mapEntry = entry;
}
else
{
if (oldestEntry == null || DateTime.Compare(entry.GetDateTime("Date"), oldestEntry.GetDateTime("Date")) < 0)
{
oldestEntry = entry;
oldestIndex = i;
}
}
}
}
// remove oldest entry if list is full
//if (maps.Count > 8) {
// maps.Remove(oldestIndex.ToString());
//}
// if current map is already in last played list, just update date
if (mapEntry != null)
{
mapEntry.Set("Date", DateTime.Now);
}
else
{
DatabaseObject entry = new DatabaseObject();
entry.Set("Map", mapKey);
entry.Set("Date", DateTime.Now);
maps.Add(entry);
}
PlayerObject.Remove("LastPlayedMaps");
//sort the array from the latest to oldest
DatabaseArray newMaps = new DatabaseArray();
int newestIndex = 0;
bool found = false;
do
{
found = false;
newestIndex = 0;
DatabaseObject newestEntry = null;
//foreach(DatabaseObject entry in maps) {
for (int i = 0; i < maps.Count; ++i)
{
if (!maps.Contains(i.ToString()))
{
continue;
}
DatabaseObject entry = maps.GetObject(i.ToString());
if (!entry.Contains("Date"))
{
continue;
}
if (newestEntry == null || DateTime.Compare(entry.GetDateTime("Date"), newestEntry.GetDateTime("Date")) > 0)
{
newestEntry = entry;
newestIndex = i;
found = true;
}
}
if (found)
{
DatabaseObject tmp = maps.GetObject(newestIndex.ToString());
maps.Remove(newestIndex.ToString());
bool duplicate = false;
foreach (DatabaseObject dbo in newMaps)
{
if (dbo.GetString("Map") == tmp.GetString("Map"))
{
duplicate = true;
break;
}
}
if (duplicate)
{
continue;
}
DatabaseObject tmp2 = new DatabaseObject();
tmp2.Set("Map", tmp.GetString("Map"));
tmp2.Set("Date", tmp.GetDateTime("Date"));
//newMaps.Add(tmp2);
newMaps.Insert(0, tmp2);
}
} while (found && newMaps.Count < 8);
//newMaps = (DatabaseArray)newMaps.Reverse();
PlayerObject.Set("LastPlayedMaps", newMaps);
/*maps = PlayerObject.GetArray("LastPlayedMaps");
* for (int i = 0; i < maps.Count; i++) {
* Console.WriteLine(maps.GetObject(i).GetString("Map"));
* }*/
savePlayerData();
}
void Awake()
{
PO = GetComponent <PlayerObject> ();
}
public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
{
return Parent.Attacked(attacker, damage, type, damageWeapon);
}
public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
{
return(Parent.Attacked(attacker, damage, type, damageWeapon));
}
public void SetOwner(PlayerObject owner)
{
player = owner;
}
public void playerGotOnline()
{
PlayerObject.Set("PresenceStatus", 1);
savePlayerData();
}
public void ChangeLeader(PlayerObject newLeader)
{
ChangeLeader(newLeader.Player);
}
//玩家捐献爵位
public void Donation(PlayerObject play, GameStruct.MONEYTYPE type, int value)
{
const int MIN_GOLD = 3000000; //最低捐献金额- 防封包
GameStruct.GUANGJUELEVEL oldlv = play.GetGuanJue();
int gold = 0;
switch (type)
{
case GameStruct.MONEYTYPE.GOLD:
{
if (gold < MIN_GOLD)
{
play.LeftNotice("最低捐献" + MIN_GOLD.ToString() + "万金币起。");
return;
}
if (play.GetMoneyCount(GameStruct.MONEYTYPE.GOLD) < value)
{
play.LeftNotice("金币不足,无法捐献！");
return;
}
gold = value;
play.ChangeAttribute(GameStruct.UserAttribute.GOLD, -gold);
break;
}
case GameStruct.MONEYTYPE.GAMEGOLD:
{
if (play.GetMoneyCount(GameStruct.MONEYTYPE.GAMEGOLD) < value)
{
play.LeftNotice("魔石不足,无法捐献！");
return;
}
play.ChangeAttribute(GameStruct.UserAttribute.GAMEGOLD, -value);
//转换成金币 一个魔石等于7100金币
const int _gold = 7100;
gold = value * _gold;
if (gold < MIN_GOLD)
{
play.LeftNotice("最低捐献" + MIN_GOLD.ToString() + "万金币起。");
return;
}
break;
}
}
play.GetBaseAttr().guanjue += (uint)gold;
SetValue(play.GetBaseAttr().player_id, play.GetName(), play.GetBaseAttr().guanjue);
//通知客户端
//重新计算一下等级
GameStruct.GUANGJUELEVEL level = this.GetLevel(play);
//爵位被改变- 发公告
if (oldlv != level)
{
this.SendChangeGuanJueMsg(play, level);
}
if (level != play.GetGuanJue())
{
play.SetGuanJue(level);
}
this.SendGuanJueInfo(play);
DB_Update(play);
}
/// <summary>
/// Called when a new player is registered.
/// </summary>
/// <param name="player">The player to register.</param>
/// <returns>True if the player should be registered.</returns>
protected virtual bool OnRegisterPlayer(PlayerObject player)
{
return true;
}
private void ReadWorld(JSONObject world, VoxelArray voxelArray)
{
var materials = new List <Material>();
if (world["materials"] != null)
{
foreach (JSONNode matNode in world["materials"].AsArray)
{
JSONObject matObject = matNode.AsObject;
materials.Add(ReadMaterial(matObject));
}
}
var substances = new List <Substance>();
if (world["substances"] != null)
{
foreach (JSONNode subNode in world["substances"].AsArray)
{
Substance s = new Substance();
ReadEntity(subNode.AsObject, s);
substances.Add(s);
}
}
if (world["global"] != null)
{
ReadPropertiesObject(world["global"].AsObject, voxelArray.world);
}
if (fileWriterVersion <= 2 && world["sky"] != null)
{
Material sky = materials[world["sky"].AsInt];
if (sky != missingMaterial) // default skybox is null
{
voxelArray.world.SetSky(sky);
}
}
if (world["map"] != null)
{
ReadMap(world["map"].AsObject, voxelArray, materials, substances);
}
if (fileWriterVersion <= 2 && world["player"] != null)
{
PlayerObject player = new PlayerObject();
ReadObjectEntity(world["player"].AsObject, player);
voxelArray.AddObject(player);
}
if (world["objects"] != null)
{
foreach (JSONNode objNode in world["objects"].AsArray)
{
JSONObject objObject = objNode.AsObject;
string typeName = objObject["name"];
var objType = GameScripts.FindTypeWithName(GameScripts.objects, typeName);
if (objType == null)
{
warnings.Add("Unrecognized object type: " + typeName);
continue;
}
ObjectEntity obj = (ObjectEntity)objType.Create();
ReadObjectEntity(objObject, obj);
voxelArray.AddObject(obj);
}
}
if (!editor)
{
// start the game
foreach (Substance s in substances)
{
s.InitEntityGameObject(voxelArray);
}
foreach (ObjectEntity obj in voxelArray.IterateObjects())
{
obj.InitEntityGameObject(voxelArray);
}
}
else // editor
{
foreach (ObjectEntity obj in voxelArray.IterateObjects())
{
obj.InitObjectMarker((VoxelArrayEditor)voxelArray);
}
}
}
public override bool IsAttackTarget(PlayerObject attacker)
{
return true;
}
public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
{
int armour = 0;
switch (type)
{
case DefenceType.ACAgility:
if (Envir.Random.Next(Agility + 1) > attacker.Accuracy)
{
return(0);
}
armour = GetAttackPower(MinAC, MaxAC);
break;
case DefenceType.AC:
armour = GetAttackPower(MinAC, MaxAC);
break;
case DefenceType.MACAgility:
if (Envir.Random.Next(Agility + 1) > attacker.Accuracy)
{
return(0);
}
armour = GetAttackPower(MinMAC, MaxMAC);
break;
case DefenceType.MAC:
armour = GetAttackPower(MinAC, MaxAC);
break;
case DefenceType.Agility:
if (Envir.Random.Next(Agility + 1) > attacker.Accuracy)
{
return(0);
}
break;
}
if (armour >= damage)
{
return(0);
}
if (damageWeapon)
{
attacker.DamageWeapon();
}
ShockTime = 0;
if (Master != null && Master != attacker)
{
if (Envir.Time > Master.BrownTime && Master.PKPoints < 200)
{
attacker.BrownTime = Envir.Time + Settings.Minute;
}
}
if (EXPOwner == null || EXPOwner.Dead)
{
EXPOwner = attacker;
}
if (EXPOwner == attacker)
{
EXPOwnerTime = Envir.Time + EXPOwnerDelay;
}
Broadcast(new S.ObjectStruck {
ObjectID = ObjectID, AttackerID = attacker.ObjectID, Direction = Direction, Location = CurrentLocation
});
attacker.GatherElement();//ArcherSpells - Elemental system
ChangeHP(-1);
return(1);
}
public override bool IsAttackTarget(PlayerObject attacker)
{
return Parent.IsAttackTarget(attacker);
}
public override bool IsAttackTarget(PlayerObject attacker)
{
return(true);
}
public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
{
int armour = 0;
switch (type)
{
case DefenceType.ACAgility:
if (Envir.Random.Next(Agility + 1) > attacker.Accuracy) return 0;
armour = GetAttackPower(MinAC, MaxAC);
break;
case DefenceType.AC:
armour = GetAttackPower(MinAC, MaxAC);
break;
case DefenceType.MACAgility:
if (Envir.Random.Next(Agility + 1) > attacker.Accuracy) return 0;
armour = GetAttackPower(MinMAC, MaxMAC);
break;
case DefenceType.MAC:
armour = GetAttackPower(MinAC, MaxAC);
break;
case DefenceType.Agility:
if (Envir.Random.Next(Agility + 1) > attacker.Accuracy) return 0;
break;
}
if (armour >= damage) return 0;
if (damageWeapon)
attacker.DamageWeapon();
ShockTime = 0;
if (Master != null && Master != attacker)
if (Envir.Time > Master.BrownTime && Master.PKPoints < 200)
attacker.BrownTime = Envir.Time + Settings.Minute;
if (EXPOwner == null || EXPOwner.Dead)
EXPOwner = attacker;
if (EXPOwner == attacker)
EXPOwnerTime = Envir.Time + EXPOwnerDelay;
Broadcast(new S.ObjectStruck { ObjectID = ObjectID, AttackerID = attacker.ObjectID, Direction = Direction, Location = CurrentLocation });
ChangeHP(-1);
return 1;
}
public override void OnMagicBegin(PlayerObject player)
{
}
