public PlayerClient(CreateObjectPacket createPacket) :
base(createPacket, Constants.PlayerModel)
{
FlameThrower = new FlameThrowerParticleSystem(Tool.Thrower.ConeAngle * 10f, 40.0f, 15.0f, Tool.Thrower.Range / 2.0f, 1.0f, Tool.Thrower.Range, 1.0f);
LeafBlower = new LeafBlowerParticleSystem();
Suction = new InverseParticleSystem(Constants.WindTexture, Vector3.Zero, -Vector3.UnitX * SUCTION_SPEED, true);
GraphicsManager.ParticleSystems.Add(FlameThrower);
GraphicsManager.ParticleSystems.Add(LeafBlower);
GraphicsManager.ParticleSystems.Add(Suction);
FlameThrower.EnableGeneration(false);
LeafBlower.EnableGeneration(false);
Suction.EnableGeneration(false);
_audioFootstep = AudioManager.GetNewSource();
_audioFlame = AudioManager.GetNewSource();
_audioWind = AudioManager.GetNewSource();
_audioSuction = AudioManager.GetNewSource();
_audioVoice = AudioManager.GetNewSource();
// Create new animations
float scale = .07f;
float timeScale = 3f;
_animWalkBlower = AnimationManager.AddAnimation(Constants.PlayerWalkBlowerAnim, new Vector3(scale), timeScale);
_animWalkThrower = AnimationManager.AddAnimation(Constants.PlayerWalkThrowerAnim, new Vector3(scale), timeScale);
_animIdle = AnimationManager.AddAnimation(Constants.PlayerIdleAnim, new Vector3(scale), timeScale);
_animVictory = AnimationManager.AddAnimation(Constants.PlayerVictoryAnim, new Vector3(scale), timeScale);
_animLose = AnimationManager.AddAnimation(Constants.PlayerDefeatAnim, new Vector3(scale), timeScale);
// set to idle animation by default
SwitchAnimation(_animIdle);
nicknameUI = new UINickname(this, Name);
Burnable = true;
}
/// <summary>
/// Constructs a new local GameObject with a model at the specified path and a specified position.
/// </summary>
/// <param name="createPacket">Initial packet for this object.</param>
/// <param name="modelPath">Path to this gameobject's model.</param>
public NetworkedGameObjectClient(CreateObjectPacket createPacket, string modelPath) : base(modelPath)
{
Id = createPacket.ObjData.IdData.ObjectId;
Transform.Position.X = createPacket.ObjData.PositionX;
Transform.Position.Y = createPacket.ObjData.PositionY;
Transform.Position.Z = createPacket.ObjData.PositionZ;
Transform.Rotation.Y = createPacket.ObjData.Rotation;
}
/// <summary>
/// Creates the activeplayer object and hooks up the input so that the
/// player moves
/// </summary>
/// <param name="createPacket">The createPacket that holds info
/// on intitial pos, etc</param>
/// <returns>the created player</returns>
private GameObject InitializeUserPlayerAndMovement(
CreateObjectPacket createPacket
)
{
// Create a new player with the specified packet info.
ActivePlayer = new PlayerClient(createPacket);
// Set the active plyer in the graphics manager.
GraphicsManager.ActivePlayer = ActivePlayer;
// Add the player to networked game objects.
NetworkedGameObjects.Add(ActivePlayer.Id, ActivePlayer);
// Set up the input manager.
SetupInputManager(ActivePlayer);
CreateMap();
return(ActivePlayer);
}
/// <summary>
/// Creates a new object from a given packet, whether that be a leaf
/// or a player.
/// </summary>
/// <param name="createPacket"></param>
/// <returns>The object which was created</returns>
public GameObject CreateObjectFromPacket(CreateObjectPacket createPacket)
{
int objId = createPacket.ObjData.IdData.ObjectId;
// Create a new packet depending on it's type.
switch (createPacket.ObjectType)
{
// Create an active player
case (ObjectType.ACTIVE_PLAYER):
var newPlayer = InitializeUserPlayerAndMovement(createPacket) as PlayerClient;
playerClients.Add(newPlayer);
newPlayer.Name = GraphicsRenderer.nicknameTextbox.Text;
return(newPlayer);
// Create an other player
case (ObjectType.PLAYER):
NetworkedGameObjectClient player = new PlayerClient(createPacket);
playerClients.Add((PlayerClient)player);
NetworkedGameObjects.Add(objId, player);
return(player);
// Create a leaf.
case (ObjectType.LEAF):
NetworkedGameObjectClient leaf = new LeafClient(createPacket);
NetworkedGameObjects.Add(objId, leaf);
return(leaf);
case (ObjectType.TREE):
Transform startTransform = new Transform();
float initX = createPacket.ObjData.PositionX;
float initY = createPacket.ObjData.PositionY;
float initZ = createPacket.ObjData.PositionZ;
startTransform.Position = new Vector3(initX, initY, initZ);
NetworkedGameObjectClient tree = new TreeClient(createPacket);
NetworkedGameObjects.Add(objId, tree);
return(tree);
}
return(null);
}
public LeafClient(CreateObjectPacket createPacket) : base(createPacket, Constants.LeafModel)
{
_audioBurning = -1;
_audioMoving = -1;
Burnable = true;
}
/// <summary>
/// Create a new tree, based on a packet sent from the server.
/// </summary>
/// <param name="createPacket">Packet of a tree being created.</param>
public TreeClient(CreateObjectPacket createPacket) : base(createPacket, Constants.TreeModel)
{
// Scale the tree to make it slightly bigger.
Transform.Scale = new Vector3(1.5f, 1.5f, 1.5f);
}
