/// <summary>
/// Initializes the variables and objects that are needed by this script.
/// </summary>
void Start ()
{
PlayerMovement = GetComponent<GoalBallPlayerMovementV1>();
CatchThrow = GetComponent<CatchThrowV2>();
dive = GetComponent<Dive>();
gameTimer = GameObject.FindGameObjectWithTag("GameController").GetComponent<GameTimer>();
}
static void Main(string[] args)
{
var _world = new World();
var entity = _world.CreateEntity();
var timer = new GameTimer();
_world.EntityMasks[entity].ClearAll();
_world.EntityMasks[entity].SetBit(ComponentType.ConsoleRendererComponent);
_world.EntityMasks[entity].SetBit(ComponentType.HealthComponent);
_world.EntityMasks[entity].SetBit(ComponentType.RegenerationComponent);
_world.EntityMasks[entity].SetBit(ComponentType.FlammableComponent);
_world.HealthComponents[entity].MaxHealth = 100;
_world.HealthComponents[entity].CurrentHealth = 100;
_world.HealthComponents[entity].Damage = 15;
_world.RegenerationComponents[entity].Frequency = 2000f;
_world.RegenerationComponents[entity].AmountToHeal = 2;
_world.FlammableComponents[entity].Duration = 10000;
_world.FlammableComponents[entity].Frequency = 1500;
_world.FlammableComponents[entity].Damage = 6;
while (true)
{
timer.Reset();
_world.Update(166);
while (timer.GetTicks() < 166);
}
}
// ================================================================================================================
// EXTENDED INTERFACE ---------------------------------------------------------------------------------------------
void Awake() {
DontDestroyOnLoad(gameObject);
instance = this;
_timer = new GameTimer();
_sceneManager = new SceneManager();
}
public Accelerator(IGame game, Vector2 position, float acceleration)
: base(game, game.ContentProvider.GetAcceleratorSprite(), position, 10)
{
Requires.Range(acceleration > 0, "acceleration");
_acceleration = acceleration;
_timer = new GameTimer(BonusPeriod);
}
public override void Initialize(GameContext context)
{
base.Initialize(context);
audioHandler = ServiceLocator.Get<IAudioHandler>();
soundTimer = new GameTimer(TimeSpan.FromMilliseconds(500));
}
// Use this for initialization
//I am the 2th edition of github pj
void Start()
{
timer = new GameTimer();
timer.mTime = 3;
timer.Tick+=OnTick;
StartCoroutine( timer.Update( 0.1f ) );
}
void Awake () {
if (Instance == null) {
Instance = this;
}
else {
Destroy(gameObject);
}
}
public void Start()
{
_gameTimer = (GameTimer)GameObject.Find("SceneController").GetComponent("GameTimer");
_rotationSpeed = _rotationSpeeds[position];
_timeUnit = _timeUnits[position];
_currentX = startingRotationX;
transform.rotation = Quaternion.Euler((float)startingRotationX, 0, 90);
}
// Use this for initialization
void Start()
{
gTimer = this.gameObject.GetComponent<GameTimer>();
doorCS = GameObject.FindGameObjectWithTag("Door").GetComponent<Door>();
//personOBJ = GameObject.FindGameObjectWithTag("Detection").GetComponent<DetectionZone>().personOBJ.GetComponent<Person>();
}
// so we can make a static instance and refer
// to the game timer time as a global
void Awake()
{
if (g != null) {
DestroyImmediate (gameObject);
return;
}
g = this;
}
public BonusGenerator(IGame game)
: base(game)
{
_acceleratorTimer = new GameTimer(TimeSpan.FromSeconds(Game.Random.Next(3, 10)));
_lifeTimer = new GameTimer(TimeSpan.FromSeconds(Game.Random.Next(15, 25)));
_timeTimer = new GameTimer(TimeSpan.FromSeconds(Game.Random.Next(5, 15)));
_scoresTimer = new GameTimer(TimeSpan.FromSeconds(Game.Random.Next(5,15)));
}
void Start(){
if (text_component == null)
text_component = GetComponent<Text> ();
if (timer == null)
timer = GetComponent<GameTimer> ();
if (GameTimer.start_hour == GameTimer.end_hour)
format = TimeFormat.Real;
}
public void Awake() {
lastTick = Time.time;
if (REF == null) {
DontDestroyOnLoad(this);
REF = this;
} else {
Destroy (this.gameObject);
}
}
public void Initialize(GameContext context, int capacity)
{
this.context = context;
this.capacity = capacity;
items = new List<NotificationItem>(capacity);
fadeTimer = new GameTimer(TimeSpan.FromMilliseconds(50));
}
internal Keyboard(DKeyboard keyboard)
{
System.Diagnostics.Debug.Assert(keyboard != null);
_dKeyboard = keyboard;
_inputState = KeyboardInput.CreateEmpty();
_lastPressedKeys = new List<Key>();
(_timer = new GameTimer()).Start();
_currentDirectInputState = new KeyboardState();
}
// Use this for initialization
void Start()
{
gc = gameObject.GetComponent<GameController>();
be = gameObject.GetComponent<BlurEffect>();
cs = gameObject.GetComponent<CameraShake>();
fe = gameObject.GetComponent<FadeEffect>();
te = gameObject.GetComponent<TwirlEffect>();
gt = gameObject.GetComponent<GameTimer>();
}
public GameOver(Game game, SpriteFont font, ContentManager Content)
{
this.Content = Content;
_font = font;
Timer = new GameTimer(game, 5f);
Timer.Font = _font;
_restart = false;
_writeTexture = Content.Load<Texture2D>("Textures/Invisable.png");
}
void Start()
{
//find refernces for in-game objects
turrets = GameObject.FindGameObjectsWithTag(Tags.miniTurrret);
cc = GameObject.FindGameObjectWithTag(Tags.crystal).GetComponent<CrystalController>();
pc = GameObject.FindGameObjectWithTag(Tags.player).GetComponent<PlayerController>();
gec = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent<GUIElementsController>();
gt = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent<GameTimer>();
gameEnded = false;
}
void Start () {
score = new Score();
if (timer == null)
timer = GetComponent<GameTimer> ();
GameSettingsComponent.rx_working_rules.Take(1).Subscribe ((settings) => {
score.settings = settings;
});
score.baskets.rx_baskets = BasketComponent.rx_baskets.RxSelect(comp=>{
return comp.score_data;
});
}
/// <summary>
/// Retrieve the necessary object and script references
/// </summary>
void Start()
{
GameObject gameController = GameObject.FindGameObjectWithTag("GameController");
gameTimer = gameController.GetComponent<GameTimer>();
scoreKeeper = gameController.GetComponent<ScoreKeeper>();
referee = GameObject.FindGameObjectWithTag("Referee").GetComponent<Referee>();
breakTimer = GameObject.Find("BreakTimer").GetComponent<BreakTimer>();
timer = gameObject.GetComponent<Timer>();
timer.SetLengthOfTimer(announcementPauseLength);
}
public AnimatedSprite(Texture2D texture, SpriteInfo spriteInfo, Vector2 position, bool randomStartFrame = false)
: base(texture, position)
{
_spriteInfo = spriteInfo;
_timer = new GameTimer(TimeSpan.FromSeconds((double) 1/spriteInfo.FramesPerSecond));
_frameWidth = (float) Texture.Width/_spriteInfo.ColCount;
_frameHeight = (float) Texture.Height/_spriteInfo.RowCount;
if (randomStartFrame)
_currentFrame = new Random().Next(_spriteInfo.FrameCount - 1);
_framesRectangles = new Rectangle[_spriteInfo.FrameCount];
InitFramesRectangles();
}
public void Awake()
{
// Coins
_marioCoins = (GUIText)GameObject.Find("GUI/MarioCoins/CoinValue").GetComponent("GUIText");
_mario = (CharacterState)GameObject.Find("MarioSprite").GetComponent("CharacterState");
_twinCoins = (GUIText)GameObject.Find("GUI/MarioTwinCoins/CoinValue").GetComponent("GUIText");
_twin = (CharacterState)GameObject.Find("MarioTwinSprite").GetComponent("CharacterState");
// Timer
_timeValue = (GUIText)GameObject.Find("GUI/TimeValue").GetComponent("GUIText");
_gameTimer = (GameTimer)GameObject.Find("SceneController").GetComponent("GameTimer");
}
public MainPage(Option option)
{
this.InitializeComponent();
MainCanvas.LayoutUpdated += (sender, args) =>
{
if (!once)
{
WCFLogger.Info("Application started {0}", DateTime.Now.ToShortDateString());
this.MainCanvas.Children.Add(this._fleeEllipse);
this._world = new World(MainCanvas);
menuControl.World = this._world;
this._timer = new GameTimer(this.TimerCallback);
MainCanvas.MouseMove += this.MainPage_MouseMove;
once = true;
var scenario = new SavedScenario();
scenario.BoidsNumber = 100;
switch (option)
{
case Option.Custom:
break;
case Option.Wander:
scenario.WorldStatus = WorldStatus.GlobalWander;
break;
case Option.FCAS:
scenario.WorldStatus = WorldStatus.GlobalFCAS;
break;
case Option.Separater:
scenario.WorldStatus = WorldStatus.GlobalSeparate;
break;
case Option.Cohesion:
scenario.WorldStatus = WorldStatus.GlobalCohesion;
break;
default:
throw new ArgumentOutOfRangeException("option");
}
ApplyScenario(scenario);
}
else
{
_world.WorldHeight = MainCanvas.ActualHeight;
_world.WorldWidth = MainCanvas.ActualWidth;
}
};
}
public override void Start()
{
base.Start(); // Make sure to call this first
displayFace = false;
gameObject.renderer.enabled = false;
BuildOk = SetupPlanes();
// give it a random texture with alpha
//mDisplayPlaneOne.renderer.material = matArray[0];
//mDisplayPlaneOne.renderer.material.color = new Color(1,1,1,0);
mTimer = new GameTimer();
startTimer = false;
currentTime = 0.0f;
}
public void Awake()
{
_gameTimer = (GameTimer)GetComponent("GameTimer");
_centeredWhiteText.alignment = TextAnchor.MiddleCenter;
_centeredWhiteText.normal.textColor = Color.white;
_boxPosition.Add("left", (Screen.width - _boxSize["width"]) / 2);
_boxPosition.Add("top", (Screen.height - _boxSize["height"]) / 2 - 100);
_displayBox = new Rect(_boxPosition["left"], _boxPosition["top"], _boxSize["width"], _boxSize["height"]);
_pausedBox = new Rect(_boxPosition["left"], _boxPosition["top"] + 20, 100, 10);
}
internal Mouse(Form form, DMouse mouse)
{
System.Diagnostics.Debug.Assert(form != null);
System.Diagnostics.Debug.Assert(mouse != null);
_dMouse = mouse;
_form = form;
_inputState = MouseInput.CreateEmpty();
_currentPressedButtons = new List<MouseButton>(5);
_lastPressedButtons = new List<MouseButton>(5);
(_timer = new GameTimer()).Start();
_currentState = new MouseState();
}
public WorldRenderXna()
{
_wvm = ViewModelLocator.WorldViewModel;
if (ViewModelBase.IsInDesignModeStatic)
return;
InitializeComponent();
_gameTimer = new GameTimer();
_wvm.PreviewChanged += PreviewChanged;
_wvm.PropertyChanged += _wvm_PropertyChanged;
_wvm.RequestZoom += _wvm_RequestZoom;
_wvm.RequestScroll += _wvm_RequestScroll;
}
/// <summary>
/// Gets the objects and initializes the variables to their proper values.
/// </summary>
void Start ()
{
if (isServer)
{
BlueTeamScore = 0;
RedTeamScore = 0;
}
GameObject gameController = GameObject.FindGameObjectWithTag("GameController");
GT = gameController.GetComponent<GameTimer>();
BR = gameController.GetComponent<BallReset>();
Ref = GameObject.FindGameObjectWithTag("Referee").GetComponent<Referee>();
BT = GameObject.Find("BreakTimer").GetComponent<BreakTimer>();
}
public WorldRenderXna()
{
// to stop visual studio design time crash :(
if (!Debugging.IsInDesignMode)
{
InitializeComponent();
_gameTimer = new GameTimer();
}
_wvm = ViewModelLocator.WorldViewModel;
_wvm.PreviewChanged += PreviewChanged;
_wvm.PropertyChanged += _wvm_PropertyChanged;
_wvm.RequestZoom += _wvm_RequestZoom;
_wvm.RequestScroll += _wvm_RequestScroll;
}
public SpawnDrop spawnDrop; //where player starts the game
#endregion Fields
#region Methods
void Awake()
{
jgs = GameObject.FindGameObjectWithTag(TagsAndLayers.gameController).GetComponent<JumpGameState>();
musicController = GameObject.FindGameObjectWithTag(TagsAndLayers.musicController).GetComponent<MusicController>();
gameTimer = GameObject.FindGameObjectWithTag(TagsAndLayers.gameTimer).GetComponent<GameTimer>();
deathArea = GameObject.FindGameObjectWithTag(TagsAndLayers.deathArea).GetComponent<DeathArea>();
spawnDrop = GameObject.FindGameObjectWithTag(TagsAndLayers.spawnDrop).GetComponent<SpawnDrop>();
menuScreen = GameObject.FindGameObjectWithTag(TagsAndLayers.menuController).GetComponent<MenuScreen>();
pause = Camera.main.GetComponent<Pause>();
crosshair = Camera.main.GetComponent<Crosshair>();
objectSpawners = GameObject.FindGameObjectsWithTag(TagsAndLayers.objectSpawner);
jumppadPillars = GameObject.FindGameObjectsWithTag(TagsAndLayers.jumppadPillar);
player = GameObject.FindGameObjectWithTag(TagsAndLayers.player);
}
/// <summary>
/// Resurrects living
/// </summary>
/// <param name="living"></param>
protected virtual void ResurrectLiving(GameLiving living)
{
if (m_caster.ObjectState != GameObject.eObjectState.Active)
{
return;
}
if (m_caster.CurrentRegionID != living.CurrentRegionID)
{
return;
}
living.Health = living.MaxHealth * m_spell.ResurrectHealth / 100;
int tempManaEnd = m_spell.ResurrectMana / 100;
living.Mana = living.MaxMana * tempManaEnd;
//The spec rez spells are the only ones that have endurance
if (!SpellLine.IsBaseLine)
{
living.Endurance = living.MaxEndurance * tempManaEnd;
}
else
{
living.Endurance = 0;
}
living.MoveTo(m_caster.CurrentRegionID, m_caster.X, m_caster.Y, m_caster.Z, m_caster.Heading);
GameTimer resurrectExpiredTimer = null;
lock (m_resTimersByLiving.SyncRoot)
{
resurrectExpiredTimer = (GameTimer)m_resTimersByLiving[living];
m_resTimersByLiving.Remove(living);
}
if (resurrectExpiredTimer != null)
{
resurrectExpiredTimer.Stop();
}
GamePlayer player = living as GamePlayer;
if (player != null)
{
player.StopReleaseTimer();
player.Out.SendPlayerRevive(player);
player.UpdatePlayerStatus();
player.Out.SendMessage("You have been resurrected by " + m_caster.GetName(0, false) + "!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
player.Notify(GamePlayerEvent.Revive, player, new RevivedEventArgs(Caster, Spell));
//Lifeflight add this should make it so players who have been ressurected don't take damage for 5 seconds
RezDmgImmunityEffect rezImmune = new RezDmgImmunityEffect();
rezImmune.Start(player);
IList <GameObject> attackers;
lock (player.Attackers) { attackers = new List <GameObject>(player.Attackers); }
foreach (GameObject attacker in attackers)
{
if (attacker is GameLiving && attacker != living.TargetObject)
{
attacker.Notify(
GameLivingEvent.EnemyHealed,
attacker,
new EnemyHealedEventArgs(living, m_caster, GameLiving.eHealthChangeType.Spell, living.Health));
}
}
GamePlayer casterPlayer = Caster as GamePlayer;
if (casterPlayer != null)
{
long rezRps = player.LastDeathRealmPoints * (Spell.ResurrectHealth + 50) / 1000;
if (rezRps > 0)
{
casterPlayer.GainRealmPoints(rezRps);
}
else
{
casterPlayer.Out.SendMessage("The player you resurrected was not worth realm points on death.", eChatType.CT_Important, eChatLoc.CL_SystemWindow);
casterPlayer.Out.SendMessage("You thus get no realm points for the resurrect.", eChatType.CT_Important, eChatLoc.CL_SystemWindow);
}
}
}
}
public void Update(GameTimer gameTime)
{
cam.Update(gameTime);
rotatingLight.Update(gameTime);
}
public override void SendHouse(House house)
{
using (GSTCPPacketOut pak = new GSTCPPacketOut(GetPacketCode(eServerPackets.HouseCreate)))
{
pak.WriteShort((ushort)house.HouseNumber);
pak.WriteShort((ushort)house.Position.Z);
pak.WriteInt((uint)house.Position.X);
pak.WriteInt((uint)house.Position.Y);
pak.WriteShort((ushort)house.Heading);
pak.WriteShort((ushort)house.PorchRoofColor);
int flagPorchAndGuildEmblem = (house.Emblem & 0x010000) >> 13; //new Guild Emblem
if (house.Porch)
{
flagPorchAndGuildEmblem |= 1;
}
if (house.OutdoorGuildBanner)
{
flagPorchAndGuildEmblem |= 2;
}
if (house.OutdoorGuildShield)
{
flagPorchAndGuildEmblem |= 4;
}
pak.WriteShort((ushort)flagPorchAndGuildEmblem);
pak.WriteShort((ushort)house.Emblem);
pak.WriteShort(0); // new in 1.89b+ (scheduled for resposession XXX hourses ago)
pak.WriteByte((byte)house.Model);
pak.WriteByte((byte)house.RoofMaterial);
pak.WriteByte((byte)house.WallMaterial);
pak.WriteByte((byte)house.DoorMaterial);
pak.WriteByte((byte)house.TrussMaterial);
pak.WriteByte((byte)house.PorchMaterial);
pak.WriteByte((byte)house.WindowMaterial);
pak.WriteByte(0);
pak.WriteShort(0); // new in 1.89b+
pak.WritePascalString(house.Name);
SendTCP(pak);
}
// Update cache
m_gameClient.HouseUpdateArray[new Tuple <ushort, ushort>(house.RegionID, (ushort)house.HouseNumber)] = GameTimer.GetTickCount();
}
public override void SendHouseOccupied(House house, bool flagHouseOccuped)
{
using (GSTCPPacketOut pak = new GSTCPPacketOut(GetPacketCode(eServerPackets.HouseChangeGarden)))
{
pak.WriteShort((ushort)house.HouseNumber);
pak.WriteShort(0); // sheduled for repossession (in hours) new in 1.89b+
pak.WriteByte(0x00);
pak.WriteByte((byte)(flagHouseOccuped ? 1 : 0));
SendTCP(pak);
}
// Update cache
m_gameClient.HouseUpdateArray.UpdateIfExists(new Tuple <ushort, ushort>(house.RegionID, (ushort)house.HouseNumber), GameTimer.GetTickCount());
}
public override void SendGarden(House house, int i)
{
using (GSTCPPacketOut pak = new GSTCPPacketOut(GetPacketCode(eServerPackets.HouseChangeGarden)))
{
pak.WriteShort((ushort)house.HouseNumber);
pak.WriteShort(0); // sheduled for repossession (in hours) new in 1.89b+
pak.WriteByte(0x01);
pak.WriteByte(0x00); // update
OutdoorItem item = (OutdoorItem)house.OutdoorItems[i];
pak.WriteByte((byte)i);
pak.WriteShort((ushort)item.Model);
pak.WriteByte((byte)item.Position);
pak.WriteByte((byte)item.Rotation);
SendTCP(pak);
}
// Update cache
m_gameClient.HouseUpdateArray.UpdateIfExists(new Tuple <ushort, ushort>(house.RegionID, (ushort)house.HouseNumber), GameTimer.GetTickCount());
}
public void ResurrectLiving(GamePlayer resurrectedPlayer, GameLiving rezzer)
{
if (rezzer.ObjectState != GameObject.eObjectState.Active)
{
return;
}
if (rezzer.CurrentRegionID != resurrectedPlayer.CurrentRegionID)
{
return;
}
resurrectedPlayer.Health = (int)(resurrectedPlayer.MaxHealth * m_resurrectValue / 100);
resurrectedPlayer.Mana = (int)(resurrectedPlayer.MaxMana * m_resurrectValue / 100);
resurrectedPlayer.Endurance = (int)(resurrectedPlayer.MaxEndurance * m_resurrectValue / 100); //no endurance after any rez
resurrectedPlayer.MoveTo(rezzer.CurrentRegionID, rezzer.X, rezzer.Y, rezzer.Z, rezzer.Heading);
GameLiving living = resurrectedPlayer as GameLiving;
GameTimer resurrectExpiredTimer = null;
lock (m_resTimersByLiving.SyncRoot)
{
resurrectExpiredTimer = (GameTimer)m_resTimersByLiving[living];
m_resTimersByLiving.Remove(living);
}
if (resurrectExpiredTimer != null)
{
resurrectExpiredTimer.Stop();
}
resurrectedPlayer.StopReleaseTimer();
resurrectedPlayer.Out.SendPlayerRevive(resurrectedPlayer);
resurrectedPlayer.UpdatePlayerStatus();
GameSpellEffect effect = SpellHandler.FindEffectOnTarget(resurrectedPlayer, "PveResurrectionIllness");
if (effect != null)
{
effect.Cancel(false);
}
GameSpellEffect effecttwo = SpellHandler.FindEffectOnTarget(resurrectedPlayer, "RvrResurrectionIllness");
if (effecttwo != null)
{
effecttwo.Cancel(false);
}
resurrectedPlayer.Out.SendMessage("You have been resurrected by " + rezzer.GetName(0, false) + "!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
//Lifeflight: this should make it so players who have been ressurected don't take damage for 5 seconds
RezDmgImmunityEffect rezImmune = new RezDmgImmunityEffect();
rezImmune.Start(resurrectedPlayer);
//Lifeflight: We need to reward rez RPs
GamePlayer casterPlayer = rezzer as GamePlayer;
if (casterPlayer != null)
{
long rezRps = resurrectedPlayer.LastDeathRealmPoints * (m_resurrectValue + 50) / 1000;
if (rezRps > 0)
{
casterPlayer.GainRealmPoints(rezRps);
}
else
{
casterPlayer.Out.SendMessage("The player you resurrected was not worth realm points on death.", eChatType.CT_Important, eChatLoc.CL_SystemWindow);
casterPlayer.Out.SendMessage("You thus get no realm points for the resurrect.", eChatType.CT_Important, eChatLoc.CL_SystemWindow);
}
}
}
// Update is called once per frame
void Update()
{
var totalTime = GameState.GetAllLevelsTime();
_text.text = totalTime > 0f ? GameTimer.FormatTime(totalTime) : "-";
}
private void MainTimerEvent(object sender, EventArgs e)
{
if (playerhealth > 1)
{
healthBar.Value = playerhealth;
}
else
{
gameOver = true;
player.Image = Properties.Resources.dead;
GameTimer.Stop();
}
txtAmmo.Text = "Ammo: " + ammo;
txtScore.Text = "Kills: " + score;
if (goLeft == true && player.Left > 0)
{
player.Left -= speed;
}
if (goRight == true && player.Left + player.Width < this.ClientSize.Width)
{
player.Left += speed;
}
if (goUp == true && player.Top > 41)
{
player.Top -= speed;
}
if (goDown == true && player.Top + player.Height < this.ClientSize.Height)
{
player.Top += speed;
}
foreach (Control x in this.Controls)
{
if (x is PictureBox && (string)x.Tag == "ammo")
{
if (player.Bounds.IntersectsWith(x.Bounds))
{
this.Controls.Remove(x);
((PictureBox)x).Dispose();
ammo += 5;
}
}
if (x is PictureBox && (string)x.Tag == "zombie")
{
if (player.Bounds.IntersectsWith(x.Bounds))
{
playerhealth -= 1;
}
if (x.Left > player.Left)
{
x.Left -= ZombieSpeed;
((PictureBox)x).Image = Properties.Resources.zleft;
}
if (x.Left < player.Left)
{
x.Left += ZombieSpeed;
((PictureBox)x).Image = Properties.Resources.zright;
}
if (x.Top > player.Top)
{
x.Top -= ZombieSpeed;
((PictureBox)x).Image = Properties.Resources.zup;
}
if (x.Top < player.Top)
{
x.Top += ZombieSpeed;
((PictureBox)x).Image = Properties.Resources.zdown;
}
}
foreach (Control j in this.Controls)
{
if (j is PictureBox && (string)j.Tag == "bullet" && x is PictureBox && (string)x.Tag == "zombie")
{
if (x.Bounds.IntersectsWith(j.Bounds))
{
score++;
this.Controls.Remove(j);
((PictureBox)j).Dispose();
this.Controls.Remove(x);
((PictureBox)x).Dispose();
zombiesList.Remove(((PictureBox)x));
MakeZombies();
}
}
}
}
}
/// <summary>
/// The load content.
/// </summary>
/// <param name="contentManager">
/// The content manager.
/// </param>
public void LoadContent(ContentManager contentManager)
{
this.spriteSheet = contentManager.Load <Texture2D>(@"Textures\SpriteSheet");
this.hearbeatTimer = new GameTimer();
this.shotTimer = new GameTimer();
}
public void end()
{
saveStats();
GameTimer.Stop();
mainScreen();
}
void Start()
{
inventory = new Storage(8);
// TODO: InventorySlotUIFiller.FillInventory();
GameTimer.Join(this);
}
public void ShowTimer() => GameTimer.ShowTimerEvent(time);
/// <summary>
/// Starts the timer with defined initial delay
/// </summary>
/// <param name="initialDelay">The initial timer delay. Must be more than 0 and less than MaxInterval</param>
public override void Start(int initialDelay)
{
base.Start(initialDelay);
m_timeSinceStart = initialDelay;
LastStartedTick = GameTimer.GetTickCount();
}
private void button1_Click(object sender, EventArgs e)
{
GameTimer.Stop();
}
void Start()
{
GameTimer.SetTimer(limitTime);
levelControl = GameObject.FindGameObjectWithTag("LevelController");
}
private void Start()
{
gameTimer = GameTimer.Instance;
textManager = TextManager.Instance;
}
private void button2_Click(object sender, EventArgs e)
{
GameTimer.Start();
}
public void CompleteLevel()
{
if (Ended == false)
{
Ended = true;
this.gameObject.GetComponent <AudioSource>().GetComponent <AudioSource>().Play();
GameTimer.StopTimer();
GameObject.FindObjectOfType <CompleteWindow> ().GetComponent <CompleteWindow> ().OnLevelComplete(GameTimer.GetTime(), GameTimer.GetTime(), GameTimer.GetTime());
}
}
private void MainGameTimerEvent(object sender, EventArgs e)
{
txtScore.Text = "Score: " + score + Environment.NewLine + "Press esc to exit to Main Menu";
Player.Top += jumpSpeed;
if (goLeft == true)
{
Player.Left -= playerSpeed;
}
if (goRight == true)
{
Player.Left += playerSpeed;
}
if (jumping == true && force < 0)
{
jumping = false;
}
if (jumping == true)
{
jumpSpeed = -8;
force -= 1;
}
else
{
jumpSpeed = 10;
}
foreach (Control x in this.Controls)
{
if (x is PictureBox)
{
if ((string)x.Tag == "platform")
{
if (Player.Bounds.IntersectsWith(x.Bounds))
{
force = 8;
Player.Top = x.Top - Player.Height;
if ((string)x.Name == "HorizontalPlatform" && goLeft == false || (string)x.Name == "HorizontalPlatform" && goRight == false)
{
Player.Left -= horizontalSpeed;
}
}
x.BringToFront();
}
if ((string)x.Tag == "Coin")
{
if (Player.Bounds.IntersectsWith(x.Bounds) && x.Visible == true)
{
x.Visible = false;
score++;
}
}
if ((string)x.Tag == "enemy")
{
if (Player.Bounds.IntersectsWith(x.Bounds))
{
isGameOver = true;
txtScore.Text = "Score: " + score + Environment.NewLine + "You were Killed";
GameTimer.Stop();
}
}
}
}
HorizontalPlatform.Left -= horizontalSpeed;
if (HorizontalPlatform.Left < 0 || HorizontalPlatform.Left + HorizontalPlatform.Width > this.ClientSize.Width)
{
horizontalSpeed = -horizontalSpeed;
}
VerticlePlatform.Top += verticalSpeed;
if (VerticlePlatform.Top < 380 || VerticlePlatform.Top > 550)
{
verticalSpeed = -verticalSpeed;
}
EnemyOne.Left -= enemyOneSpeed;
if (EnemyOne.Left < pictureBox16.Left || EnemyOne.Left + EnemyOne.Width > pictureBox16.Left + pictureBox16.Width)
{
enemyOneSpeed = -enemyOneSpeed;
}
EnemyTwo.Left -= enemyTwoSpeed;
if (EnemyTwo.Left < VerticlePlatform.Left || EnemyTwo.Left + EnemyTwo.Width > VerticlePlatform.Left + VerticlePlatform.Width)
{
enemyTwoSpeed = -enemyTwoSpeed;
}
if (Player.Top + Player.Height > this.ClientSize.Height + 50)
{
GameTimer.Stop();
isGameOver = true;
txtScore.Text = "score: " + score + Environment.NewLine + "You fell!";
}
if (Player.Bounds.IntersectsWith(door.Bounds) && score == 13)
{
GameTimer.Stop();
Win = true;
txtScore.Text = "Score: " + score + Environment.NewLine + "All coins collected, You Win!" + Environment.NewLine + "Press enter for Main menu";
}
else
{
txtScore.Text = "Score: " + score + Environment.NewLine + "collect the coins" + Environment.NewLine + "(Press esc to exit to Main Menu)";
}
}
//Starts the level
//Spawn items here, set objects etc
void StartLevel()
{
GameTimer.StartTimer();
}
//When the timer has ran out this function will be called, this should end the level
public void OnTimesUp()
{
this.gameObject.GetComponent <AudioSource>().GetComponent <AudioSource>().Play();
Debug.Log("Times Up");
GameObject.FindObjectOfType <CompleteWindow> ().GetComponent <CompleteWindow> ().OnLevelComplete(GameTimer.GetTime(), GameTimer.GetTime(), GameTimer.GetTime());
}
//Обновление view после события
public void UpdateView(MineSweeperModel model)
{
var iterator = model.cellBoard.GetEnumerator();
lbCountMine.Text = MineCount.ToString();
while (iterator.MoveNext())
{
int x = iterator.Current.X;
int y = iterator.Current.Y;
if (iterator.Current.IsOpened)
{
int type = (int)iterator.Current.Type;
//Выставление соответсвующей картинки для типа мина
if (type == (int)ModelGame.Type.Mine)
{
SetImageCellMine(iterator.Current, x, y);
continue;
}
//Выставление соответсвующей картинки для не мин
SetImageCellNotMine(type, x, y);
continue;
}
else if (iterator.Current.IsFlagged)
{
cells[x, y].Image = Properties.Resources.flag;
}
else
{
cells[x, y].Image = Properties.Resources.unmarked;
}
}
//проверка игря на проигрыш
if (model.GetStatusGame() == GameStatus.GameOver)
{
GameTimer.Stop();
//Отменить действие нажатия на оставшихся ячейках
iterator = model.cellBoard.GetEnumerator();
while (iterator.MoveNext())
{
int x = iterator.Current.X;
int y = iterator.Current.Y;
if (iterator.Current.IsFlagged && (iterator.Current.Type != ModelGame.Type.Mine))
{
cells[x, y].Image = Properties.Resources.notmine;
}
if (!iterator.Current.IsOpened)
{
cells[x, y].MouseDown -= new MouseEventHandler(bttnClick);
}
}
btnFace.Image = Properties.Resources.smiley_lose;
}
//проверка игры на выигрыш
if (model.GetStatusGame() == GameStatus.Win)
{
GameTimer.Stop();
MessageBox.Show("Вы победили!!!");
}
}
public override void SendGarden(House house)
{
using (GSTCPPacketOut pak = new GSTCPPacketOut(GetPacketCode(eServerPackets.HouseChangeGarden)))
{
pak.WriteShort((ushort)house.HouseNumber);
pak.WriteShort(0); // sheduled for repossession (in hours) new in 1.89b+
pak.WriteByte((byte)house.OutdoorItems.Count);
pak.WriteByte(0x80);
foreach (var entry in house.OutdoorItems.OrderBy(entry => entry.Key))
{
OutdoorItem item = entry.Value;
pak.WriteByte((byte)entry.Key);
pak.WriteShort((ushort)item.Model);
pak.WriteByte((byte)item.Position);
pak.WriteByte((byte)item.Rotation);
}
SendTCP(pak);
}
// Update cache
m_gameClient.HouseUpdateArray.UpdateIfExists(new Tuple <ushort, ushort>(house.RegionID, (ushort)house.HouseNumber), GameTimer.GetTickCount());
}
private void endGame()
{
GameTimer.Stop();
ScoreText.Text += " Game Over !!!";
}
// Use this for initialization
void Start()
{
gTimer = GameObject.Find("Game Manager").GetComponent <GameTimer>();
}
//static int lastZ=int.MinValue;
public void HandlePacket(GameClient client, GSPacketIn packet)
{
//Tiv: in very rare cases client send 0xA9 packet before sending S<=C 0xE8 player world initialize
if ((client.Player.ObjectState != GameObject.eObjectState.Active) ||
(client.ClientState != GameClient.eClientState.Playing))
{
return;
}
int environmentTick = Environment.TickCount;
int packetVersion;
if (client.Version > GameClient.eClientVersion.Version171)
{
packetVersion = 172;
}
else
{
packetVersion = 168;
}
int oldSpeed = client.Player.CurrentSpeed;
//read the state of the player
packet.Skip(2); //PID
ushort data = packet.ReadShort();
int speed = (data & 0x1FF);
// if(!GameServer.ServerRules.IsAllowedDebugMode(client)
// && (speed > client.Player.MaxSpeed + SPEED_TOL))
if ((data & 0x200) != 0)
{
speed = -speed;
}
if (client.Player.IsMezzed || client.Player.IsStunned)
{
// Nidel: updating client.Player.CurrentSpeed instead of speed
client.Player.CurrentSpeed = 0;
}
else
{
client.Player.CurrentSpeed = (short)speed;
}
client.Player.IsStrafing = ((data & 0xe000) != 0);
int realZ = packet.ReadShort();
ushort xOffsetInZone = packet.ReadShort();
ushort yOffsetInZone = packet.ReadShort();
ushort currentZoneID;
if (packetVersion == 168)
{
currentZoneID = (ushort)packet.ReadByte();
packet.Skip(1); //0x00 padding for zoneID
}
else
{
currentZoneID = packet.ReadShort();
}
//Dinberg - Instance considerations.
//Now this gets complicated, so listen up! We have told the client a lie when it comes to the zoneID.
//As a result, every movement update, they are sending a lie back to us. Two liars could get confusing!
//BUT, the lie we sent has a truth to it - the geometry and layout of the zone. As a result, the zones
//x and y offsets will still actually be relevant to our current zone. And for the clones to have been
//created, there must have been a real zone to begin with, of id == instanceZone.SkinID.
//So, although our client is lying to us, and thinks its in another zone, that zone happens to coincide
//exactly with the zone we are instancing - and so all the positions still ring true.
//Philosophically speaking, its like looking in a mirror and saying 'Am I a reflected, or reflector?'
//What it boils down to has no bearing whatsoever on the result of anything, so long as someone sitting
//outside of the unvierse knows not to listen to whether you say which you are, and knows the truth to the
//answer. Then, he need only know what you are doing ;)
Zone newZone = WorldMgr.GetZone(currentZoneID);
if (newZone == null)
{
if (client.Player == null)
{
return;
}
if (!client.Player.TempProperties.getProperty("isbeingbanned", false))
{
if (log.IsErrorEnabled)
{
log.Error(client.Player.Name + "'s position in unknown zone! => " + currentZoneID);
}
GamePlayer player = client.Player;
player.TempProperties.setProperty("isbeingbanned", true);
player.MoveToBind();
}
return; // TODO: what should we do? player lost in space
}
// move to bind if player fell through the floor
if (realZ == 0)
{
client.Player.MoveTo(
(ushort)client.Player.BindRegion,
client.Player.BindXpos,
client.Player.BindYpos,
(ushort)client.Player.BindZpos,
(ushort)client.Player.BindHeading
);
return;
}
int realX = newZone.XOffset + xOffsetInZone;
int realY = newZone.YOffset + yOffsetInZone;
bool zoneChange = newZone != client.Player.LastPositionUpdateZone;
if (zoneChange)
{
//If the region changes -> make sure we don't take any falling damage
if (client.Player.LastPositionUpdateZone != null && newZone.ZoneRegion.ID != client.Player.LastPositionUpdateZone.ZoneRegion.ID)
{
client.Player.MaxLastZ = int.MinValue;
}
// Update water level and diving flag for the new zone
client.Out.SendPlayerPositionAndObjectID();
zoneChange = true;
/*
* "You have entered Burial Tomb."
* "Burial Tomb"
* "Current area is adjusted for one level 1 player."
* "Current area has a 50% instance bonus."
*/
string description = newZone.Description;
string screenDescription = description;
var translation = client.GetTranslation(newZone) as DBLanguageZone;
if (translation != null)
{
if (!Util.IsEmpty(translation.Description))
{
description = translation.Description;
}
if (!Util.IsEmpty(translation.ScreenDescription))
{
screenDescription = translation.ScreenDescription;
}
}
client.Out.SendMessage(LanguageMgr.GetTranslation(client.Account.Language, "PlayerPositionUpdateHandler.Entered", description),
eChatType.CT_System, eChatLoc.CL_SystemWindow);
client.Out.SendMessage(screenDescription, eChatType.CT_ScreenCenterSmaller, eChatLoc.CL_SystemWindow);
client.Player.LastPositionUpdateZone = newZone;
}
int coordsPerSec = 0;
int jumpDetect = 0;
int timediff = Environment.TickCount - client.Player.LastPositionUpdateTick;
int distance = 0;
if (timediff > 0)
{
distance = client.Player.LastPositionUpdatePoint.GetDistanceTo(new Point3D(realX, realY, realZ));
coordsPerSec = distance * 1000 / timediff;
if (distance < 100 && client.Player.LastPositionUpdatePoint.Z > 0)
{
jumpDetect = realZ - client.Player.LastPositionUpdatePoint.Z;
}
}
#region DEBUG
#if OUTPUT_DEBUG_INFO
if (client.Player.LastPositionUpdatePoint.X != 0 && client.Player.LastPositionUpdatePoint.Y != 0)
{
log.Debug(client.Player.Name + ": distance = " + distance + ", speed = " + oldSpeed + ", coords/sec=" + coordsPerSec);
}
if (jumpDetect > 0)
{
log.Debug(client.Player.Name + ": jumpdetect = " + jumpDetect);
}
#endif
#endregion DEBUG
client.Player.LastPositionUpdateTick = Environment.TickCount;
client.Player.LastPositionUpdatePoint.X = realX;
client.Player.LastPositionUpdatePoint.Y = realY;
client.Player.LastPositionUpdatePoint.Z = realZ;
int tolerance = ServerProperties.Properties.CPS_TOLERANCE;
if (client.Player.Steed != null && client.Player.Steed.MaxSpeed > 0)
{
tolerance += client.Player.Steed.MaxSpeed;
}
else if (client.Player.MaxSpeed > 0)
{
tolerance += client.Player.MaxSpeed;
}
if (client.Player.IsJumping)
{
coordsPerSec = 0;
jumpDetect = 0;
client.Player.IsJumping = false;
}
if (client.Player.IsAllowedToFly == false && (coordsPerSec > tolerance || jumpDetect > ServerProperties.Properties.JUMP_TOLERANCE))
{
bool isHackDetected = true;
if (coordsPerSec > tolerance)
{
// check to see if CPS time tolerance is exceeded
int lastCPSTick = client.Player.TempProperties.getProperty <int>(LASTCPSTICK, 0);
if (environmentTick - lastCPSTick > ServerProperties.Properties.CPS_TIME_TOLERANCE)
{
isHackDetected = false;
}
}
if (isHackDetected)
{
StringBuilder builder = new StringBuilder();
builder.Append("MOVEHACK_DETECT");
builder.Append(": CharName=");
builder.Append(client.Player.Name);
builder.Append(" Account=");
builder.Append(client.Account.Name);
builder.Append(" IP=");
builder.Append(client.TcpEndpointAddress);
builder.Append(" CPS:=");
builder.Append(coordsPerSec);
builder.Append(" JT=");
builder.Append(jumpDetect);
ChatUtil.SendDebugMessage(client, builder.ToString());
if (client.Account.PrivLevel == 1)
{
GameServer.Instance.LogCheatAction(builder.ToString());
if (ServerProperties.Properties.ENABLE_MOVEDETECT)
{
if (ServerProperties.Properties.BAN_HACKERS && false) // banning disabled until this technique is proven accurate
{
DBBannedAccount b = new DBBannedAccount();
b.Author = "SERVER";
b.Ip = client.TcpEndpointAddress;
b.Account = client.Account.Name;
b.DateBan = DateTime.Now;
b.Type = "B";
b.Reason = string.Format("Autoban MOVEHACK:(CPS:{0}, JT:{1}) on player:{2}", coordsPerSec, jumpDetect, client.Player.Name);
GameServer.Database.AddObject(b);
GameServer.Database.SaveObject(b);
string message = "";
message = "You have been auto kicked and banned due to movement hack detection!";
for (int i = 0; i < 8; i++)
{
client.Out.SendMessage(message, eChatType.CT_Help, eChatLoc.CL_SystemWindow);
client.Out.SendMessage(message, eChatType.CT_Help, eChatLoc.CL_ChatWindow);
}
client.Out.SendPlayerQuit(true);
client.Player.SaveIntoDatabase();
client.Player.Quit(true);
}
else
{
string message = "";
message = "You have been auto kicked due to movement hack detection!";
for (int i = 0; i < 8; i++)
{
client.Out.SendMessage(message, eChatType.CT_Help, eChatLoc.CL_SystemWindow);
client.Out.SendMessage(message, eChatType.CT_Help, eChatLoc.CL_ChatWindow);
}
client.Out.SendPlayerQuit(true);
client.Player.SaveIntoDatabase();
client.Player.Quit(true);
}
client.Disconnect();
return;
}
}
}
client.Player.TempProperties.setProperty(LASTCPSTICK, environmentTick);
}
ushort headingflag = packet.ReadShort();
client.Player.Heading = (ushort)(headingflag & 0xFFF);
ushort flyingflag = packet.ReadShort();
byte flags = (byte)packet.ReadByte();
if (client.Player.X != realX || client.Player.Y != realY)
{
client.Player.TempProperties.setProperty(LASTMOVEMENTTICK, client.Player.CurrentRegion.Time);
}
client.Player.X = realX;
client.Player.Y = realY;
client.Player.Z = realZ;
if (zoneChange)
{
// update client zone information for waterlevel and diving
client.Out.SendPlayerPositionAndObjectID();
}
// used to predict current position, should be before
// any calculation (like fall damage)
client.Player.MovementStartTick = Environment.TickCount;
// Begin ---------- New Area System -----------
if (client.Player.CurrentRegion.Time > client.Player.AreaUpdateTick) // check if update is needed
{
var oldAreas = client.Player.CurrentAreas;
// Because we may be in an instance we need to do the area check from the current region
// rather than relying on the zone which is in the skinned region. - Tolakram
var newAreas = client.Player.CurrentRegion.GetAreasOfZone(newZone, client.Player);
// Check for left areas
if (oldAreas != null)
{
foreach (IArea area in oldAreas)
{
if (!newAreas.Contains(area))
{
area.OnPlayerLeave(client.Player);
}
}
}
// Check for entered areas
foreach (IArea area in newAreas)
{
if (oldAreas == null || !oldAreas.Contains(area))
{
area.OnPlayerEnter(client.Player);
}
}
// set current areas to new one...
client.Player.CurrentAreas = newAreas;
client.Player.AreaUpdateTick = client.Player.CurrentRegion.Time + 2000; // update every 2 seconds
}
// End ---------- New Area System -----------
client.Player.TargetInView = ((flags & 0x10) != 0);
client.Player.GroundTargetInView = ((flags & 0x08) != 0);
client.Player.IsTorchLighted = ((flags & 0x80) != 0);
//7 6 5 4 3 2 1 0
//15 14 13 12 11 10 9 8
// 1 1
const string SHLASTUPDATETICK = "SHPLAYERPOSITION_LASTUPDATETICK";
const string SHLASTFLY = "SHLASTFLY_STRING";
const string SHLASTSTATUS = "SHLASTSTATUS_STRING";
int SHlastTick = client.Player.TempProperties.getProperty <int>(SHLASTUPDATETICK);
int SHlastFly = client.Player.TempProperties.getProperty <int>(SHLASTFLY);
int SHlastStatus = client.Player.TempProperties.getProperty <int>(SHLASTSTATUS);
int SHcount = client.Player.TempProperties.getProperty <int>(SHSPEEDCOUNTER);
int status = (data & 0x1FF ^ data) >> 8;
int fly = (flyingflag & 0x1FF ^ flyingflag) >> 8;
if (client.Player.IsJumping)
{
SHcount = 0;
}
if (SHlastTick != 0 && SHlastTick != environmentTick)
{
if (((SHlastStatus == status || (status & 0x8) == 0)) && ((fly & 0x80) != 0x80) && (SHlastFly == fly || (SHlastFly & 0x10) == (fly & 0x10) || !((((SHlastFly & 0x10) == 0x10) && ((fly & 0x10) == 0x0) && (flyingflag & 0x7FF) > 0))))
{
if ((environmentTick - SHlastTick) < 400)
{
SHcount++;
if (SHcount > 1 && client.Account.PrivLevel > 1)
{
//Apo: ?? no idea how to name the first parameter for language translation: 1: ??, 2: {detected} ?, 3: {count} ?
client.Out.SendMessage(string.Format("SH: ({0}) detected: {1}, count {2}", 500 / (environmentTick - SHlastTick), environmentTick - SHlastTick, SHcount), eChatType.CT_Staff, eChatLoc.CL_SystemWindow);
}
if (SHcount % 5 == 0)
{
StringBuilder builder = new StringBuilder();
builder.Append("TEST_SH_DETECT[");
builder.Append(SHcount);
builder.Append("] (");
builder.Append(environmentTick - SHlastTick);
builder.Append("): CharName=");
builder.Append(client.Player.Name);
builder.Append(" Account=");
builder.Append(client.Account.Name);
builder.Append(" IP=");
builder.Append(client.TcpEndpointAddress);
GameServer.Instance.LogCheatAction(builder.ToString());
if (client.Account.PrivLevel > 1)
{
client.Out.SendMessage("SH: Logging SH cheat.", eChatType.CT_Damaged, eChatLoc.CL_SystemWindow);
if (SHcount >= ServerProperties.Properties.SPEEDHACK_TOLERANCE)
{
client.Out.SendMessage("SH: Player would have been banned!", eChatType.CT_Damaged, eChatLoc.CL_SystemWindow);
}
}
if ((client.Account.PrivLevel == 1) && SHcount >= ServerProperties.Properties.SPEEDHACK_TOLERANCE)
{
if (ServerProperties.Properties.BAN_HACKERS)
{
DBBannedAccount b = new DBBannedAccount();
b.Author = "SERVER";
b.Ip = client.TcpEndpointAddress;
b.Account = client.Account.Name;
b.DateBan = DateTime.Now;
b.Type = "B";
b.Reason = string.Format("Autoban SH:({0},{1}) on player:{2}", SHcount, environmentTick - SHlastTick, client.Player.Name);
GameServer.Database.AddObject(b);
GameServer.Database.SaveObject(b);
string message = "";
message = "You have been auto kicked and banned for speed hacking!";
for (int i = 0; i < 8; i++)
{
client.Out.SendMessage(message, eChatType.CT_Help, eChatLoc.CL_SystemWindow);
client.Out.SendMessage(message, eChatType.CT_Help, eChatLoc.CL_ChatWindow);
}
client.Out.SendPlayerQuit(true);
client.Player.SaveIntoDatabase();
client.Player.Quit(true);
}
else
{
string message = "";
message = "You have been auto kicked for speed hacking!";
for (int i = 0; i < 8; i++)
{
client.Out.SendMessage(message, eChatType.CT_Help, eChatLoc.CL_SystemWindow);
client.Out.SendMessage(message, eChatType.CT_Help, eChatLoc.CL_ChatWindow);
}
client.Out.SendPlayerQuit(true);
client.Player.SaveIntoDatabase();
client.Player.Quit(true);
}
client.Disconnect();
return;
}
}
}
else
{
SHcount = 0;
}
SHlastTick = environmentTick;
}
}
else
{
SHlastTick = environmentTick;
}
int state = ((data >> 10) & 7);
client.Player.IsClimbing = (state == 7);
client.Player.IsSwimming = (state == 1);
if (state == 3 && client.Player.TempProperties.getProperty <bool>(GamePlayer.DEBUG_MODE_PROPERTY, false) == false && client.Player.IsAllowedToFly == false) //debugFly on, but player not do /debug on (hack)
{
StringBuilder builder = new StringBuilder();
builder.Append("HACK_FLY");
builder.Append(": CharName=");
builder.Append(client.Player.Name);
builder.Append(" Account=");
builder.Append(client.Account.Name);
builder.Append(" IP=");
builder.Append(client.TcpEndpointAddress);
GameServer.Instance.LogCheatAction(builder.ToString());
{
if (ServerProperties.Properties.BAN_HACKERS)
{
DBBannedAccount b = new DBBannedAccount();
b.Author = "SERVER";
b.Ip = client.TcpEndpointAddress;
b.Account = client.Account.Name;
b.DateBan = DateTime.Now;
b.Type = "B";
b.Reason = string.Format("Autoban flying hack: on player:{0}", client.Player.Name);
GameServer.Database.AddObject(b);
GameServer.Database.SaveObject(b);
}
string message = "";
message = "Client Hack Detected!";
for (int i = 0; i < 6; i++)
{
client.Out.SendMessage(message, eChatType.CT_System, eChatLoc.CL_SystemWindow);
client.Out.SendMessage(message, eChatType.CT_System, eChatLoc.CL_ChatWindow);
}
client.Out.SendPlayerQuit(true);
client.Disconnect();
return;
}
}
SHlastFly = fly;
SHlastStatus = status;
client.Player.TempProperties.setProperty(SHLASTUPDATETICK, SHlastTick);
client.Player.TempProperties.setProperty(SHLASTFLY, SHlastFly);
client.Player.TempProperties.setProperty(SHLASTSTATUS, SHlastStatus);
client.Player.TempProperties.setProperty(SHSPEEDCOUNTER, SHcount);
lock (client.Player.LastUniqueLocations)
{
GameLocation[] locations = client.Player.LastUniqueLocations;
GameLocation loc = locations[0];
if (loc.X != realX || loc.Y != realY || loc.Z != realZ || loc.RegionID != client.Player.CurrentRegionID)
{
loc = locations[locations.Length - 1];
Array.Copy(locations, 0, locations, 1, locations.Length - 1);
locations[0] = loc;
loc.X = realX;
loc.Y = realY;
loc.Z = realZ;
loc.Heading = client.Player.Heading;
loc.RegionID = client.Player.CurrentRegionID;
}
}
//**************//
//FALLING DAMAGE//
//**************//
if (GameServer.ServerRules.CanTakeFallDamage(client.Player) && client.Player.IsSwimming == false)
{
int maxLastZ = client.Player.MaxLastZ;
/* Are we on the ground? */
if ((flyingflag >> 15) != 0)
{
int safeFallLevel = client.Player.GetAbilityLevel(Abilities.SafeFall);
int fallSpeed = (flyingflag & 0xFFF) - 100 * safeFallLevel; // 0x7FF fall speed and 0x800 bit = fall speed overcaped
int fallMinSpeed = 400;
int fallDivide = 6;
if (client.Version >= GameClient.eClientVersion.Version188)
{
fallMinSpeed = 500;
fallDivide = 15;
}
int fallPercent = Math.Min(99, (fallSpeed - (fallMinSpeed + 1)) / fallDivide);
if (fallSpeed > fallMinSpeed)
{
client.Out.SendMessage(LanguageMgr.GetTranslation(client.Account.Language, "PlayerPositionUpdateHandler.FallingDamage"),
eChatType.CT_Damaged, eChatLoc.CL_SystemWindow);
client.Player.CalcFallDamage(fallPercent);
}
client.Player.MaxLastZ = client.Player.Z;
}
else
{
// always set Z if on the ground
if (flyingflag == 0)
{
client.Player.MaxLastZ = client.Player.Z;
}
// set Z if in air and higher than old Z
else if (maxLastZ < client.Player.Z)
{
client.Player.MaxLastZ = client.Player.Z;
}
}
}
//**************//
byte[] con168 = packet.ToArray();
con168[0] = (byte)(client.SessionID >> 8);
con168[1] = (byte)(client.SessionID & 0xff);
//Riding is set here!
if (client.Player.Steed != null && client.Player.Steed.ObjectState == GameObject.eObjectState.Active)
{
client.Player.Heading = client.Player.Steed.Heading;
con168[2] = 0x18; // Set ride flag 00011000
con168[3] = 0; // player speed = 0 while ride
con168[12] = (byte)(client.Player.Steed.ObjectID >> 8); //heading = steed ID
con168[13] = (byte)(client.Player.Steed.ObjectID & 0xFF);
con168[14] = (byte)0;
con168[15] = (byte)(client.Player.Steed.RiderSlot(client.Player)); // there rider slot this player
}
else if (!client.Player.IsAlive)
{
con168[2] &= 0xE3; //11100011
con168[2] |= 0x14; //Set dead flag 00010100
}
//diving is set here
con168[16] &= 0xFB; //11 11 10 11
if ((con168[16] & 0x02) != 0x00)
{
client.Player.IsDiving = true;
con168[16] |= 0x04;
}
else
{
client.Player.IsDiving = false;
}
con168[16] &= 0xFC; //11 11 11 00 cleared Wireframe & Stealth bits
if (client.Player.IsWireframe)
{
con168[16] |= 0x01;
}
//stealth is set here
if (client.Player.IsStealthed)
{
con168[16] |= 0x02;
}
con168[17] = (byte)((con168[17] & 0x80) | client.Player.HealthPercent);
// zone ID has changed in 1.72, fix bytes 11 and 12
byte[] con172 = (byte[])con168.Clone();
if (packetVersion == 168)
{
// client sent v168 pos update packet, fix 172 version
con172[10] = 0;
con172[11] = con168[10];
}
else
{
// client sent v172 pos update packet, fix 168 version
con168[10] = con172[11];
con168[11] = 0;
}
GSUDPPacketOut outpak168 = new GSUDPPacketOut(client.Out.GetPacketCode(eServerPackets.PlayerPosition));
//Now copy the whole content of the packet
outpak168.Write(con168, 0, 18 /*con168.Length*/);
outpak168.WritePacketLength();
GSUDPPacketOut outpak172 = new GSUDPPacketOut(client.Out.GetPacketCode(eServerPackets.PlayerPosition));
//Now copy the whole content of the packet
outpak172.Write(con172, 0, 18 /*con172.Length*/);
outpak172.WritePacketLength();
// byte[] pak168 = outpak168.GetBuffer();
// byte[] pak172 = outpak172.GetBuffer();
// outpak168 = null;
// outpak172 = null;
GSUDPPacketOut outpak190 = null;
GSUDPPacketOut outpak1112 = new GSUDPPacketOut(client.Out.GetPacketCode(eServerPackets.PlayerPosition));
outpak1112.Write(con172, 0, 18 /*con172.Length*/);
outpak1112.WriteByte(client.Player.ManaPercent);
outpak1112.WriteByte(client.Player.EndurancePercent);
outpak1112.WriteByte((byte)(client.Player.RPFlag ? 1 : 0));
outpak1112.WriteByte(0); //outpak1112.WriteByte((con168.Length == 22) ? con168[21] : (byte)0);
outpak1112.WritePacketLength();
foreach (GamePlayer player in client.Player.GetPlayersInRadius(WorldMgr.VISIBILITY_DISTANCE))
{
if (player == null)
{
continue;
}
//No position updates for ourselves
if (player == client.Player)
{
// Update Player Cache (Client sending Packet is admitting he's already having it)
player.Client.GameObjectUpdateArray[new Tuple <ushort, ushort>(client.Player.CurrentRegionID, (ushort)client.Player.ObjectID)] = GameTimer.GetTickCount();
continue;
}
//no position updates in different houses
if ((client.Player.InHouse || player.InHouse) && player.CurrentHouse != client.Player.CurrentHouse)
{
continue;
}
if (client.Player.MinotaurRelic != null)
{
MinotaurRelic relic = client.Player.MinotaurRelic;
if (!relic.Playerlist.Contains(player) && player != client.Player)
{
relic.Playerlist.Add(player);
player.Out.SendMinotaurRelicWindow(client.Player, client.Player.MinotaurRelic.Effect, true);
}
}
if (!client.Player.IsStealthed || player.CanDetect(client.Player))
{
// Update Player Cache
player.Client.GameObjectUpdateArray[new Tuple <ushort, ushort>(client.Player.CurrentRegionID, (ushort)client.Player.ObjectID)] = GameTimer.GetTickCount();
//forward the position packet like normal!
if (player.Client.Version >= GameClient.eClientVersion.Version1112)
{
player.Out.SendUDPRaw(outpak1112);
}
else if (player.Client.Version >= GameClient.eClientVersion.Version190)
{
if (outpak190 == null)
{
outpak190 = new GSUDPPacketOut(client.Out.GetPacketCode(eServerPackets.PlayerPosition));
outpak190.Write(con172, 0, 18 /*con172.Length*/);
outpak190.WriteByte(client.Player.ManaPercent);
outpak190.WriteByte(client.Player.EndurancePercent);
outpak190.FillString(client.Player.CharacterClass.Name, 32);
// roleplay flag, if == 1, show name (RP) with gray color
if (client.Player.RPFlag)
{
outpak190.WriteByte(1);
}
else
{
outpak190.WriteByte(0);
}
outpak190.WriteByte((con168.Length == 54) ? con168[53] : (byte)0); // send last byte for 190+ packets
outpak190.WritePacketLength();
}
player.Out.SendUDPRaw(outpak190);
}
else if (player.Client.Version >= GameClient.eClientVersion.Version172)
{
player.Out.SendUDPRaw(outpak172);
}
else
{
player.Out.SendUDPRaw(outpak168);
}
}
else
{
player.Out.SendObjectDelete(client.Player); //remove the stealthed player from view
}
}
if (client.Player.CharacterClass.ID == (int)eCharacterClass.Warlock)
{
//Send Chamber effect
client.Player.Out.SendWarlockChamberEffect(client.Player);
}
//handle closing of windows
//trade window
if (client.Player.TradeWindow != null)
{
if (client.Player.TradeWindow.Partner != null)
{
if (!client.Player.IsWithinRadius(client.Player.TradeWindow.Partner, WorldMgr.GIVE_ITEM_DISTANCE))
{
client.Player.TradeWindow.CloseTrade();
}
}
}
}
public void Draw(GameTimer gameTime)
{
scene.Render(gameTime);
}
//Set initial values
void Start()
{
gameManager = FindObjectOfType <GameManager>();
timer = FindObjectOfType <GameTimer>();
sprite = this.gameObject.GetComponent <SpriteRenderer>();
}
public bool HandlePacket(Peer peer, byte[] data)
{
var peerInfo = _playerManager.GetPeerInfo(peer);
if (!peerInfo.IsDisconnected)
{
_game.IncrementReadyPlayers();
}
/* if (_game.IsRunning)
* return true; */
if (_game.PlayersReady == _playerManager.GetPlayers().Count)
{
var start = new StatePacket(PacketCmd.PKT_S2C_StartGame);
_game.PacketHandlerManager.broadcastPacket(start, Channel.CHL_S2C);
foreach (var player in _playerManager.GetPlayers())
{
if (player.Item2.Peer == peer && !player.Item2.IsMatchingVersion)
{
var dm = new DebugMessage("Your client version does not match the server. Check the server log for more information.");
_game.PacketHandlerManager.sendPacket(peer, dm, Channel.CHL_S2C);
}
_game.PacketNotifier.NotifyUpdatedStats(player.Item2.Champion, false);
}
_game.Start();
}
if (_game.IsRunning)
{
var map = _game.Map;
if (peerInfo.IsDisconnected)
{
foreach (var player in _playerManager.GetPlayers())
{
if (player.Item2.Team == peerInfo.Team)
{
var heroSpawnPacket = new HeroSpawn2(player.Item2.Champion);
_game.PacketHandlerManager.sendPacket(peer, heroSpawnPacket, Channel.CHL_S2C);
/* This is probably not the best way
* of updating a champion's level, but it works */
var levelUpPacket = new LevelUp(player.Item2.Champion);
_game.PacketHandlerManager.sendPacket(peer, levelUpPacket, Channel.CHL_S2C);
}
}
peerInfo.IsDisconnected = false;
_game.PacketNotifier.NotifyUnitAnnounceEvent(UnitAnnounces.SummonerReconnected, peerInfo.Champion);
// Send the initial game time sync packets, then let the map send another
float gameTime = map.GameTime / 1000.0f;
var timer = new GameTimer(gameTime); // 0xC1
_game.PacketHandlerManager.sendPacket(peer, timer, Channel.CHL_S2C);
var timer2 = new GameTimerUpdate(gameTime); // 0xC2
_game.PacketHandlerManager.sendPacket(peer, timer2, Channel.CHL_S2C);
return(true);
}
foreach (var p in _playerManager.GetPlayers())
{
map.AddObject(p.Item2.Champion);
// Send the initial game time sync packets, then let the map send another
float gameTime = map.GameTime / 1000.0f;
var timer = new GameTimer(gameTime); // 0xC1
_game.PacketHandlerManager.sendPacket(p.Item2.Peer, timer, Channel.CHL_S2C);
var timer2 = new GameTimerUpdate(gameTime); // 0xC2
_game.PacketHandlerManager.sendPacket(p.Item2.Peer, timer2, Channel.CHL_S2C);
}
}
return(true);
}
/// <summary>
/// Do the mob AI
/// </summary>
public override void Think()
{
GamePlayer playerowner = GetPlayerOwner();
long lastUpdate;
if (!playerowner.Client.GameObjectUpdateArray.TryGetValue(new Tuple <ushort, ushort>(Body.CurrentRegionID, (ushort)Body.ObjectID), out lastUpdate))
{
lastUpdate = 0;
}
// Load abilities on first Think cycle.
if (!checkAbility)
{
CheckAbilities();
checkAbility = true;
}
if (playerowner != null && (GameTimer.GetTickCount() - lastUpdate) > ThinkInterval)
{
playerowner.Out.SendObjectUpdate(Body);
}
//See if the pet is too far away, if so release it!
if (Owner is GamePlayer && IsMainPet)
{
if (!Body.IsWithinRadius(Owner, MAX_OWNER_FOLLOW_DIST))
{
(Owner as GamePlayer).CommandNpcRelease();
}
}
// if pet is in agressive mode then check aggressive spells and attacks first
if (AggressionState == eAggressionState.Aggressive)
{
CheckPlayerAggro();
CheckNPCAggro();
AttackMostWanted();
}
if (Body.IsCasting == false && Body.IsAttacking == false)
{
// Check for buffs, heals, etc
// Only prevent casting if we are ordering pet to come to us or go to target
if (Owner is GameNPC || (Owner is GamePlayer && WalkState != eWalkState.ComeHere && WalkState != eWalkState.GoTarget))
{
CheckSpells(eCheckSpellType.Defensive);
}
}
// Stop hunting player entering in steath
if (Body.TargetObject != null && Body.TargetObject is GamePlayer)
{
GamePlayer player = Body.TargetObject as GamePlayer;
if (Body.IsAttacking && player.IsStealthed && !previousIsStealthed)
{
Body.StopAttack();
Body.StopCurrentSpellcast();
RemoveFromAggroList(player);
Body.TargetObject = null;
FollowOwner();
}
previousIsStealthed = player.IsStealthed;
}
}
