protected override void LoadContent()
{
#region Globalization
Globe.Batches = new Batch[1] {
new Batch(GraphicsDevice)
};
Globe.Form = (Form)Control.FromHandle(Window.Handle);
Globe.GameWindow = Window;
Globe.ContentManager = Content;
Globe.GraphicsDevice = GraphicsDevice;
Globe.Viewport = GraphicsDevice.Viewport;
Globe.GraphicsAdapter = GraphicsDevice.Adapter;
Globe.TextureLoader = new TextureLoader(Globe.GraphicsDevice);
Textures.LoadTextures(System.IO.Path.Combine(Globe.ExecutableDirectory, "Content"));
#endregion
Screen.Expand(true);
Sound.Initialize(256);
Performance.UpdateFramesPerSecondBuffer = new float[180];
Performance.DrawFramesPerSecondBuffer = new float[3];
MultiPlayer.Initialize();
IsMouseVisible = true;
Mod.Fore = Mod.LoadTiles(@".\Content\Fore.xml");
Mod.Back = Mod.LoadTiles(@".\Content\Back.xml");
Mod.Weapons = Mod.LoadWeapons(@".\Content\Weapons.xml");
}
public bool PlaceBack(byte ID, int x, int y, bool Self = false)
{
if (!InBounds(x, y) || (ID == 0))
{
return(false);
}
Mod.Tile Tile = Mod.Back[ID];
Point Point = new Point(x, y);
if (Tiles[x, y].Back == ID)
{
return(false);
}
if (Tile.Frames > 0)
{
Tiles[x, y].BackAnimation = new Animation(("Tiles.Back." + ID + "-"), Tile.Frames, true, Tile.Speed);
}
else
{
Tiles[x, y].BackAnimation = null;
}
Tiles[x, y].Back = ID;
if (Self && (MultiPlayer.Peer() != null))
{
MultiPlayer.Send(MultiPlayer.Construct(Game.Packets.PlaceBack, ID, (ushort)x, (ushort)y));
}
return(true);
}
public PutOpeation(string route, string data, Callback <string> callback, MultiPlayer multiPlayer)
{
Route = route;
Data = data;
Response = callback;
MultiPlayer = multiPlayer;
}
public bool ClearFore(int x, int y, bool Self = false)
{
if (!InBounds(x, y) || !Tiles[x, y].HasFore)
{
return(false);
}
Mod.Tile Tile = Mod.Fore[Tiles[x, y].Fore];
Point Point = new Point(x, y);
Pathfinder.SetNode(Point, new Pathfinder.Node(true));
if (Tile.Waypoint.HasValue)
{
Waypoints[Tile.Waypoint.Value].Remove(Point);
}
if (Tile.Spawn.HasValue)
{
Spawns[Tile.Spawn.Value].Remove(Point);
}
Tiles[x, y].Fore = 0;
Tiles[x, y].Angle = 0;
Tiles[x, y].ForeAnimation = null;
if (Self && (MultiPlayer.Peer() != null))
{
MultiPlayer.Send(MultiPlayer.Construct(Game.Packets.ClearFore, (ushort)x, (ushort)y));
}
return(true);
}
public GameManager() : base("GameManager")
{
SetupState setupState = new SetupState(this);
MenuState menuState = new MenuState(this);
SinglePlayer singleMode = new SinglePlayer(this);
PauseState pauseState = new PauseState(this);
LoseState loseState = new LoseState(this);
WinState winState = new WinState(this);
MultiPlayer multiMode = new MultiPlayer(this);
LobbySetup lobby = new LobbySetup(this);
//Link State
setupState.MenuState = menuState;
menuState.SinglePlayerMode = singleMode;
menuState.Lobby = lobby;
singleMode.NextWin = winState;
singleMode.NextLose = loseState;
singleMode.NextPause = pauseState;
lobby.Menu = menuState;
lobby.MultiMode = multiMode;
multiMode.NextLose = loseState;
multiMode.NextPause = pauseState;
multiMode.NextWin = winState;
loseState.Retry = menuState;
setupState.OnStateEnter();
currentState = setupState;
AddComponent(new FSMUpdater(currentState));
}
public static void QuitLobby()
{
MultiPlayer.Shutdown("Game", string.Empty);
Players = null;
Map = null;
Timers.Remove("Positions");
State = States.MainMenu;
}
protected override void OnExiting(object sender, EventArgs args)
{
if ((Map != null) && (State == States.MapEditor) && MultiPlayer.IsNullOrServer())
{
Map.Save(@".\map.dat");
}
QuitLobby();
base.OnExiting(sender, args);
}
public void CheckWinTest_True()
{
MultiPlayer.gameResources.OptionNumber = 100;
MultiPlayer.gameResources.HiddenNumber = 100;
MultiPlayer.CheckWin();
Assert.IsTrue(MultiPlayer.gameResources.Win);
}
void Start()
{
moveL.x = Resolution.width;
moveR.y = Resolution.height;
multiPlayer = GetComponent<MultiPlayer>();
multiPlayer.Refresh();
chat = GetComponent<Chat>();
multiPlayer.playerName = "Player"+Random.Range(1,255);
}
public void CheckMoreOrLessTest()
{
MultiPlayer.gameResources.OptionNumber = 10;
MultiPlayer.gameResources.HiddenNumber = 100;
var expected = MultiPlayer.CheckMoreOrLess();
Assert.IsTrue(expected == "less");
}
public void AddNewGameTypeTest()
{
var gameNumber = Player.Scores.Count;
MultiPlayer.gameResources.Score = 0;
MultiPlayer.AddNewGameType();
Assert.IsTrue(Player.Scores.Count == gameNumber + 1);
}
public void ThrowWithOnePlayerMultiPlayer()
{
List<IPlayer> collection = new List<IPlayer>();
var p1 = Substitute.For<INonNpc>();
p1.Slot.Returns(1);
collection.Add(p1);
Assert.Throws(typeof(InvalidOperationException),() => {
var singlePlayer = new MultiPlayer(collection);
});
}
public void EndGame_TotalScoreTest()
{
MultiPlayer.gameResources.Player.Scores["Multiplayer"] = 0;
var expeced = 6;
MultiPlayer.gameResources.MaxAttempt = 12;
MultiPlayer.gameResources.Attempt = 6;
MultiPlayer.EndGame();
Assert.IsTrue(expeced == MultiPlayer.gameResources.Player.Scores["Multiplayer"]);
}
public MessageManager(MultiPlayer multiPlayer, NetworkManager networkManager, string playerId)
{
InBox = new List <Message>();
Sended = new List <Message>();
MultiPlayer = multiPlayer;
NetworkManager = networkManager;
this.playerId = playerId;
}
public void Fire(Vector2 Position, float Angle)
{
FireRate = (1 / Mod.Weapons[Weapon].RoundsPerSecond);
Vector2 Start = (Position + Globe.Rotate((Mod.Weapons[Weapon].Bullet * Scale), Angle)), End = Globe.Move(Start, Angle, 2500);
Line Bullet = new Line(Start, End);
for (int x = 0; x < Map.Tiles.GetLength(0); x++)
{
for (int y = 0; y < Map.Tiles.GetLength(1); y++)
{
if (Map.Tiles[x, y].HasFore && (Mod.Fore[Map.Tiles[x, y].Fore].Type == Mod.Tile.Types.Wall))
{
Polygon Mask = Polygon.CreateCross(new Vector2(Tile.Width, Tile.Height), Vector2.Zero);
Mask.Position = new Vector2(((x * Tile.Width) + (Tile.Width / 2f)), ((y * Tile.Height) + (Tile.Height / 2f)));
Vector2 Intersection = Vector2.Zero;
if (Mask.Intersects(Bullet, ref Intersection))
{
Bullet.End = Intersection;
}
}
}
}
if (this == Self)
{
if (MultiPlayer.Type() == MultiPlayer.Types.Client)
{
MultiPlayer.Send(MultiPlayer.Construct(Packets.Fire, Position, Angle));
}
else if (MultiPlayer.Type() == MultiPlayer.Types.Server)
{
MultiPlayer.Send(MultiPlayer.Construct(Packets.Fire, Slot, Position, Angle));
}
}
else
{
for (byte i = 0; i < Players.Length; i++)
{
if ((Players[i] != null) && (Players[i] != this) && (Players[i] != Self) && ((Players[i].Team == 0) || (Team == 0) || (Players[i].Team != Team)))
{
Vector2 Intersection = Vector2.Zero;
if (Players[i].Mask.Intersects(Bullet, ref Intersection))
{
Bullet.End = Intersection;
}
}
}
if (((Team == 0) || (Self.Team == 0) || (Team != Self.Team)) && Self.Mask.Intersects(Bullet))
{
Self.Health -= Mod.Weapons[Weapon].Damage; Self.Killer = this;
}
}
//Bullets.Add(Bullet);
}
public void CalcMaxAttempt_TotalScoreTest()
{
MultiPlayer.gameResources.MinValue = 1;
MultiPlayer.gameResources.MaxValue = 100;
var calcMaxAttempt = MultiPlayer.CalcMaxAttempt(MultiPlayer.gameResources.MinValue,
MultiPlayer.gameResources.MaxValue);
var expected = 7;
Assert.IsTrue(expected == calcMaxAttempt);
}
public static bool CreateLobby(string Name)
{
if (MultiPlayer.Type("Game") == null)
{
//Map = new Map(80, 45);
Map = Map.Load(@".\map.dat");
Players = new Player[10];
Self = Player.Add(new Player(Name));
MultiPlayer.Start("Game", 6121, Players.Length);
Timers.Add("Positions", (1 / 30d));
return(true);
}
return(false);
}
/// <summary>
/// Handles the Clicked event of the MultiplayerBtn control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
private void MultiplayerBtn_Clicked(object sender, RoutedEventArgs e)
{
var location = this.PointToScreen(new Point(0, 0));
// create the multiplayer model and give it the server
IMultiPlayerModel model = new MultiPlayerModel(server);
// set up and launch the multiplayer window
MultiPlayer multiPlayer = new MultiPlayer(model, this);
multiPlayer.Left = location.X;
multiPlayer.Top = location.Y;
this.player.Pause();
multiPlayer.Show();
this.Hide();
}
public static void EndRound(VictoryStates VictoryState, byte TeamWon, byte RoundEndMusicIndex)
{
RoundTimer = 10; RoundEnded = true;
if (MultiPlayer.Type() == MultiPlayer.Types.Server)
{
List <object> Details = new List <object>();
Details.Add((byte)VictoryState);
if (VictoryState == VictoryStates.Team)
{
Details.Add(TeamWon);
}
Details.Add(RoundEndMusicIndex);
MultiPlayer.Send(MultiPlayer.Construct(Packets.EndRound, Details));
}
}
public void Init(MultiPlayer player, PunTeams.Team team)
{
this.player = player;
this.team = team;
if (PunTeams.Team.RED == team)
{
gameObject.layer = LayerMask.NameToLayer(InGameManager.RED_TEAM_PLAYER);
}
else if (PunTeams.Team.BLUE == team)
{
gameObject.layer = LayerMask.NameToLayer(InGameManager.BLUE_TEAM_PLAYER);
}
//Debug.Log("dasheffect team : " + team);
parentObj.SetActive(false);
}
public bool ClearBack(int x, int y, bool Self = false)
{
if (!InBounds(x, y) || !Tiles[x, y].HasBack)
{
return(false);
}
Mod.Tile Tile = Mod.Back[Tiles[x, y].Back];
Tiles[x, y].Back = 0;
Tiles[x, y].BackAnimation = null;
if (Self && (MultiPlayer.Peer() != null))
{
MultiPlayer.Send(MultiPlayer.Construct(Game.Packets.ClearBack, (ushort)x, (ushort)y));
}
return(true);
}
public void Initialize_TakeExistingScore(int score)
{
var gameNumber = Player.Scores.Count;
MultiPlayer.gameResources.Score = score;
MultiPlayer.gameResources.Player.Scores.Add(MultiPlayer.gameResources.GameType,
MultiPlayer.gameResources.Score);
MultiPlayer.Initialize();
var scoreWhichPlayerHasAfterInitialize =
MultiPlayer.gameResources.Player.Scores[MultiPlayer.gameResources.GameType];
Assert.AreEqual(scoreWhichPlayerHasAfterInitialize, score);
}
void Start()
{
gameMode = GameObject.FindObjectOfType <GameMode> ();
scoreDisplayPlayerTwo = GameObject.Find("Score Panel Player Two").GetComponent <ScoreDisplay> ();
isTwoPlayerGame = gameMode.isTwoPlayerGame;
if (isTwoPlayerGame)
{
Instantiate(playerTwoPrefab);
multiPlayer = GameObject.FindObjectOfType <MultiPlayer> ();
}
else
{
Instantiate(playerOnePrefab);
singlePlayer = GameObject.FindObjectOfType <SinglePlayer> ();
Destroy(scoreDisplayPlayerTwo.gameObject);
}
}
public void Respawn(Vector2 Position)
{
Killer = null; Health = 1000; Dead = false;
this.Position = Position; bool T = Collides;
InterpolatedPosition = this.Position;
if (this == Self)
{
if (MultiPlayer.Type() == MultiPlayer.Types.Client)
{
MultiPlayer.Send(MultiPlayer.Construct(Packets.Respawn, Position));
}
else if (MultiPlayer.Type() == MultiPlayer.Types.Server)
{
MultiPlayer.Send(MultiPlayer.Construct(Packets.Respawn, Slot, Position));
}
}
}
public static void NewRound()
{
RoundTimer = 0; RoundEnded = false;
for (byte i = 0; i < Players.Length; i++)
{
if (Players[i] != null)
{
Players[i].Dead = false;
}
}
Point Spawn = Map.GetSpawn(Self.Team);
Self.Respawn(new Vector2(((Spawn.X * Tile.Width) + (Tile.Width / 2f)), ((Spawn.Y * Tile.Height) + (Tile.Height / 2f))));
if (MultiPlayer.Type() == MultiPlayer.Types.Server)
{
MultiPlayer.Send(MultiPlayer.Construct(Packets.NewRound));
}
}
//What if we did a static constructor that got us all the nessesary delegates?
public static SinglePlayer CreateGame(
SinglePlayer.AdjustButtonStatus adjustButtonStatus,
SinglePlayer.UpdateImageSource updateImageSource)
{
SinglePlayer output;
if (Setting == Modes.SP)
{
output = new SinglePlayer(adjustButtonStatus, updateImageSource);
}
else if (Setting == Modes.MP)
{
output = new MultiPlayer(adjustButtonStatus, updateImageSource);
}
else
{
output = new AiPlayer(adjustButtonStatus, updateImageSource);
}
return(output);
}
private void Awake () {
sinMenu.SetActive(false);
mulMenu.SetActive(false);
mulCreate.SetActive(false);
logLobby.SetActive (false);
lobby.SetActive(false);
blackBG.SetActive(false);
difficulty = PlayerPrefs.GetInt("Difficulty",1);
map = PlayerPrefs.GetInt("Map",1);
difTxt.text = CDif();
sMap.sprite = maps[map - 1];
cMap.sprite = maps[map - 1];
count = 2;
cPlayer.text = count.ToString();
pName.text = "Player"+Random.Range(1,255);
multiPlayer = GetComponent<MultiPlayer>();
chat = GetComponent<Chat>();
audio.Stop ();
}
public void BuildsMultiPlayer()
{
List<IPlayer> collection = new List<IPlayer>();
var p1 = Substitute.For<INonNpc>();
p1.Slot.Returns(1);
collection.Add(p1);
var p2 = Substitute.For<INonNpc>();
p2.Slot.Returns(2);
collection.Add(p2);
var ai = Substitute.For<IAi>();
ai.Slot.Returns(2);
collection.Add(ai);
var singlePlayer = new MultiPlayer(collection);
Assert.AreEqual(true, singlePlayer.Players.ElementAt(0) is INonNpc);
Assert.AreEqual(true, singlePlayer.Players.ElementAt(1) is INonNpc);
Assert.AreEqual(2, singlePlayer.Players.Count());
}
/// <summary>
/// The three player toy experiment.
/// </summary>
public void ThreePlayerToyExperiment()
{
var players = new[] { "Jill", "Fred", "Steve" };
var scores = new[] { new[] { 2, 1, 0 }, new[] { 1, 2, 0 } };
var outcomes =
scores.Select(s => players.Zip(s, (p, score) => new { p, score }).ToDictionary(ia => ia.p, ia => ia.score)).ToArray();
var inputs = Inputs <MultiPlayerGame> .CreateToyInputs(outcomes);
outputter.Out(inputs,
Contents.S4ExtensionsToTheCoreModel.NumberedName,
"ThreePlayerToyExperiment",
"Inputs");
// Rerun first game with different variances
var priors = new Priors
{
Skills =
{
{ "Jill", new Gaussian(120, 400) },
{ "Fred", new Gaussian(100, inputs.InitialVariance) },
{ "Steve", new Gaussian(140, inputs.InitialVariance) }
}
};
var model = new MultiPlayer(inputs.TrueSkillParameters, ShowFactorGraph);
var threePlayerToyExperiment = new[]
{
new ToyExperiment(model, inputs.Games[0], priors),
new ToyExperiment(model, inputs.Games[1], priors)
};
outputter.Out(threePlayerToyExperiment,
Contents.S4ExtensionsToTheCoreModel.NumberedName,
"ThreePlayerToyExperiment",
"Experiments");
}
public void Die()
{
if ((this == Self) && (Killer == null))
{
Killer = Self;
}
if (Killer != null)
{
Killer.Kills++;
}
Game.RoundEndWait = 1;
Deaths++; Dead = true; RespawnTimer = Game.RespawnTimer;
if (this == Self)
{
if (MultiPlayer.Type() == MultiPlayer.Types.Client)
{
MultiPlayer.Send(MultiPlayer.Construct(Packets.Death, Killer.Slot));
}
else if (MultiPlayer.Type() == MultiPlayer.Types.Server)
{
MultiPlayer.Send(MultiPlayer.Construct(Packets.Death, Slot, Killer.Slot));
}
}
}
void Start()
{
if (!SmartFoxConnection.IsInitialized) {
Application.LoadLevel("Connection");
return;
}
smartFox = SmartFoxConnection.Connection;
smartFox.AddEventListener (SFSEvent.EXTENSION_RESPONSE, OnExtensionResponse);
Debug.Log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> add event listener");
SFSObject param = new SFSObject();
RoomVariable rv = smartFox.LastJoinedRoom.GetVariable("idGrupo");
long grupo;
grupo = (long)rv.GetIntValue();
param.PutUtfString("nick",getMyUserName());
param.PutLong("grupo",grupo);
smartFox.Send(new ExtensionRequest("cargarDatosJugador",param));
SFSObject param2 = new SFSObject();
Debug.Log ( " proyecto");
param2.PutLong ("Id_Proyecto", this.getProyecto ());
Debug.Log (this.getProyecto () + " proyecto ");
smartFox.Send(new ExtensionRequest("obtenerPathProyecto",param2));
Debug.Log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> smartfox send");
link = (MultiPlayer)GameObject.Find("Multi").GetComponent("MultiPlayer");
Debug.Log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UserVS start termino");
}
// Start is called before the first frame update
void Start()
{
MultiPlayer = GetComponent <MultiPlayer>();
MultiPlayer.StartGame();
}
void Awake()
{
instance = this;
}
public override void Update(GameTime Time)
{
if ((Animation == null) || Animation.Finished)
{
;
}
if (FireRate > 0)
{
FireRate -= Time.ElapsedGameTime.TotalSeconds;
}
if (this == Self)
{
if (Globe.Active && !Dead)
{
var OldPosition = Position;
var Run = (Keyboard.Holding(Keyboard.Keys.LeftShift) || Keyboard.Holding(Keyboard.Keys.RightShift));
if (Keyboard.Holding(Keyboard.Keys.W))
{
if (Keyboard.Holding(Keyboard.Keys.A))
{
Move(new Vector2(-(float)(Speed.X * Time.ElapsedGameTime.TotalSeconds),
-(float)(Speed.Y * Time.ElapsedGameTime.TotalSeconds)));
}
else if (Keyboard.Holding(Keyboard.Keys.D))
{
Move(new Vector2((float)(Speed.X * Time.ElapsedGameTime.TotalSeconds),
-(float)(Speed.Y * Time.ElapsedGameTime.TotalSeconds)));
}
else
{
Move(new Vector2(0, -(float)(Speed.Y * Time.ElapsedGameTime.TotalSeconds)));
}
}
else if (Keyboard.Holding(Keyboard.Keys.S))
{
if (Keyboard.Holding(Keyboard.Keys.A))
{
Move(new Vector2(-(float)(Speed.X * Time.ElapsedGameTime.TotalSeconds),
(float)(Speed.Y * Time.ElapsedGameTime.TotalSeconds)));
}
else if (Keyboard.Holding(Keyboard.Keys.D))
{
Move(new Vector2((float)(Speed.X * Time.ElapsedGameTime.TotalSeconds),
(float)(Speed.Y * Time.ElapsedGameTime.TotalSeconds)));
}
else
{
Move(new Vector2(0, (float)(Speed.Y * Time.ElapsedGameTime.TotalSeconds)));
}
}
else if (Keyboard.Holding(Keyboard.Keys.A))
{
Move(new Vector2(-(float)(Speed.X * Time.ElapsedGameTime.TotalSeconds), 0));
}
else if (Keyboard.Holding(Keyboard.Keys.D))
{
Move(new Vector2((float)(Speed.X * Time.ElapsedGameTime.TotalSeconds), 0));
}
if (OldPosition != Position)
{
}
Angle = Globe.Lerp(Angle, Globe.Angle(Position, Mouse.CameraPosition), .1f);
Camera.Position = Globe.Move(Position, Globe.Angle(Position, Mouse.CameraPosition), (Vector2.Distance(Position, Mouse.CameraPosition) / 4));
//Camera.Angle = Angle;
if (Mouse.Pressed(Mouse.Buttons.Left) && (FireRate <= 0))
{
Fire(Position, Angle);
}
}
if (RespawnTimer > 0)
{
RespawnTimer -= Time.ElapsedGameTime.TotalSeconds;
}
else if (Dead)
{
if ((GameType == GameTypes.Deathmatch) || (GameType == GameTypes.TeamDeathmatch))
{
Point Spawn = Map.GetSpawn(Team);
Respawn(new Vector2(((Spawn.X * Tile.Width) + (Tile.Width / 2f)), ((Spawn.Y * Tile.Height) + (Tile.Height / 2f))));
}
}
if ((Health <= 0) && !Dead)
{
Die();
}
if (Timers.Tick("Positions") && (MultiPlayer.Type("Game") == MultiPlayer.Types.Client))
{
MultiPlayer.Send("Game", MultiPlayer.Construct("Game", Game.Packets.Position, Position, Angle),
NetDeliveryMethod.UnreliableSequenced, 1);
}
}
Globe.Move(ref InterpolatedPosition, Position, (Vector2.Distance(InterpolatedPosition, Position) / 6));
InterpolatedAngle = Globe.Lerp(InterpolatedAngle, Angle, .125f);
base.Update(Time);
}
// Use this for initialization
void Start () {
multiPlayer = GetComponent <MultiPlayer> ();
chat = GetComponent <Chat> ();
}
public void GiveHelpTest()
{
var expected = MultiPlayer.GiveHelp();
Assert.IsFalse(expected);
}
public void Initialize_AddNewGameType()
{
MultiPlayer.Initialize();
Assert.That(Player.Scores.Count, Is.Not.EqualTo(0));
}
