/************************************************/
// Item interaction methods
private void Interact()
{
string[] tagsToScan = { "Register" };
GameObject[] excludedGameObjects = { gameObject };
GameObject closestInteractable = EssentialFunctions.GetClosestInteractableInFOV(transform, pickupArea, pickupAngle, maxPickupDistance, tagsToScan, excludedGameObjects);
if (!closestInteractable)
{
return;
}
switch (closestInteractable.tag)
{
case "Register":
{
_interactRegister = closestInteractable.GetComponent <CashRegister>();
_currentPlayerMode = PlayerMode.Cashier;
transform.position = _interactRegister.GetStandingPosition().position;
transform.rotation = _interactRegister.GetStandingPosition().rotation;
break;
}
}
}
void Awake()
{
PlayerMode = PlayerMode.Dragging;
dragButton.onClick.AddListener(() => PlayerMode = PlayerMode.Dragging);
beltButton.onClick.AddListener(() => PlayerMode = PlayerMode.Belts);
}
public void OnInteract(InputAction.CallbackContext context)
{
if (!context.performed)
{
return;
}
switch (_currentPlayerMode)
{
case PlayerMode.Walking:
{
Interact();
break;
}
case PlayerMode.Cashier:
{
_interactRegister = null;
_currentPlayerMode = PlayerMode.Walking;
break;
}
case PlayerMode.Receiving:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private void UpdateOnGameplay()
{
if (Input.GetKeyDown(KeyCode.Tab))
{
playerMode = playerMode.Next();
UpdateCharacterOnModeChange();
Debug.Log("Player mode changed to " + playerMode.ToString());
}
else if (Input.GetKeyDown(KeyCode.Escape))
{
Debug.Log("Sudoku");
teams[activeTeam].Clear();
EndGame();
}
if (currentCharacter == null)
{
StateToWaitForRoundStart();
return;
}
float stamina = currentCharacter.GetComponent <StaminaComponent>().value;
if (stamina <= 0)
{
StateToShootTime();
}
}
public void MediaPlayer_PlayStateChange()
{
var ps1 = GetMediaState();
if (ps1 == MediaState.Play && _set_on_pause)
{
_set_on_pause = false;
MediaElement.Pause();
}
if (ps1 == MediaState.Play && mode != PlayerMode.Play)
{
mode = PlayerMode.Play;
if (MediaModeChanged != null)
{
MediaModeChanged(this, EventArgs.Empty);
}
}
if (ps1 == MediaState.Pause && mode != PlayerMode.Pause)
{
mode = PlayerMode.Pause;
if (MediaModeChanged != null)
{
MediaModeChanged(this, EventArgs.Empty);
}
}
if (PlayStateChange != null)
{
PlayStateChange(this, EventArgs.Empty);
}
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Escape))
{
Application.Quit();
#if UNITY_EDITOR
UnityEditor.EditorApplication.isPlaying = false;
#endif
}
if (Input.GetKeyDown(KeyCode.LeftControl))
{
PlayerMode = PlayerMode.Belts;
}
if (Input.GetKeyUp(KeyCode.LeftControl) && PlayerMode == PlayerMode.Belts)
{
PlayerMode = PlayerMode.Dragging;
}
dragButton.interactable = !(Draggable.IsDragEnabled = PlayerMode == PlayerMode.Dragging);
beltButton.interactable = !(beltManager.enabled = PlayerMode == PlayerMode.Belts);
}
/// <summary>
/// Apply specified search and rating category filters to the next videos.
/// </summary>
/// <param name="request">The search filters being requested, or null to disable the request category mode.</param>
public async Task SetRequestCategoryAsync(SearchSettings request)
{
if (request != null)
{
FilterSettings.Search = request.Search;
if (!string.IsNullOrEmpty(request.RatingCategory) && request.RatingValue.HasValue)
{
FilterSettings.RatingCategory = request.RatingCategory;
FilterSettings.RatingOperator = request.RatingOperator;
FilterSettings.RatingValue = request.RatingValue;
}
playMode = PlayerMode.RequestCategory;
}
else
{
FilterSettings.Search = null;
FilterSettings.RatingCategory = null;
FilterSettings.RatingValue = null;
playMode = PlayerMode.Normal;
}
await SelectNextVideoAsync(0, false).ConfigureAwait(false);
Application.Current.Dispatcher.Invoke(() => PlaylistChanged?.Invoke(this, new EventArgs()));
}
// Use this for initialization
void Start()
{
itemHolder = GameObject.FindWithTag("ItemHolder").GetComponent <ItemHolder>();
player = GameObject.FindWithTag("Player");
playerMode = player.GetComponent <PlayerMode>();
shape = transform.GetChild(0).GetComponent <ParticleSystem>().shape;
}
/* #endregion */
/* ======================================================================================== */
//TODO: Move each Player Mode to it's own sub-class???
/* #region ==== P L A Y E R M O D E S =================================================== */
/* #region ---- Player Mode SWITCHER ------------------------------------------------------ */
public void SetPlayerMode(PlayerMode playerMode)
{
if (!MatchManager.MatchPlayerManager.PlayInAction)
{
clearAllModeStates();
switch (playerMode)
{
case PlayerMode.Idle:
setIdleMode();
break;
case PlayerMode.Move:
setMoveMode();
break;
case PlayerMode.Rotate:
setRotateMode();
break;
case PlayerMode.Pass:
setPassMode();
break;
default:
setIdleMode();
break;
}
}
}
public PlayerModeChangedEventArgs(Player player, PlayerMode oldPlayerMode)
{
CurrentPlayer = player;
OldPlayerMode = oldPlayerMode;
if (player != null)
NewPlayerMode = player.PlayerMode;
}
public void returnToAvatarMode()
{
//Réactivation de la caméra principale du joueur
if (fpsPlayer != null)
{
Destroy(fpsPlayer);
}
else
{
Destroy(GameObject.Find("CustomPlayer"));
}
mainPlayer.SetActive(true);
mainPlayerCamera.SetActive(true);
HUDManager hudManager = GameObject.Find("HUDManager1").GetComponent <HUDManager> ();
hudManager.resetCursor();
hudManager.showHUD();
GameObject.Find("Canvas-informations").GetComponent <InformationsCanvas> ().clearInformations();
playerMode = PlayerMode.AvatarPlayer;
fpsModeDone();
}
private void SwitchPlayerMode()
{
if (!areControlsEnabled)
{
return;
}
areControlsEnabled = false;
if (playerMode == PlayerMode.Free4All)
{
playerMode = PlayerMode.TwoVsTwo;
Dispatcher.AddAnimation(Animation.Get(0, 1, 0.3f, false, (val) =>
{
playerMode2vs2Selected.Opacity = val;
playerMode2vs2.Opacity = 1 - val;
playerModeFree4All.Opacity = val;
playerModeFree4AllSelected.Opacity = 1 - val;
}, EasingFunctions.QuadIn)).Then(() => areControlsEnabled = true);
}
else
{
playerMode = PlayerMode.Free4All;
Dispatcher.AddAnimation(Animation.Get(0, 1, 0.3f, false, (val) =>
{
playerMode2vs2Selected.Opacity = 1 - val;
playerMode2vs2.Opacity = val;
playerModeFree4All.Opacity = 1 - val;
playerModeFree4AllSelected.Opacity = val;
}, EasingFunctions.QuadIn)).Then(() => areControlsEnabled = true);
}
}
private void OnPlayerModeChange(PlayerMode newPlayerMode)
{
if (currentPlayerMode == newPlayerMode)
{
return;
}
if (isLocalPlayer)
{
switch (currentPlayerMode)
{
case PlayerMode.FirstPerson: DisableLocalFirstPersonMode(); break;
case PlayerMode.VR: DisableLocalVRMode(); break;
case PlayerMode.Observer: DisableLocalObserverMode(); break;
}
}
currentPlayerMode = newPlayerMode;
if (isLocalPlayer)
{
switch (newPlayerMode)
{
case PlayerMode.FirstPerson: EnableLocalFirstPersonMode(); break;
case PlayerMode.VR: EnableLocalVRMode(); break;
case PlayerMode.Observer: EnableLocalObserverMode(); break;
}
}
UpdatePlayerDisplayAppearance(newPlayerMode);
}
// Use this for initialization
private void Start()
{
controller = GetComponent <CharacterController>();
playerPos = transform.position;
anim = GetComponent <Animator>();
state = PlayerMode.move;
}
//Change form
private void ChangeFunction()
{
if (canTakeDamage)
{
if (gameObject.GetComponent <Enemy>() == null)
{
if (playerMode == PlayerMode.Slime)
{
playerMode = PlayerMode.Human;
colliderSlime.enabled = false;
colliderProta.enabled = true;
anim.SetBool("Slime", false);
}
else if (playerMode == PlayerMode.Human)
{
playerMode = PlayerMode.Slime;
anim.SetBool("Slime", true);
colliderSlime.enabled = true;
colliderProta.enabled = false;
}
}
else
{
GetComponent <Collider2D>().enabled = false;
}
}
}
private void ResetPlayingData()
{
PlayMode = PlayerMode.None;
m_FramePlayingIndex = 0;
m_PassedFixedUpdate = 0f;
m_FramesToPlay.Clear();
}
private void PlayHawkEyeUpdate()
{
if (PlayMode != PlayerMode.PlayHawkEye)
{
return;
}
//没有播放内容
if (m_FramesToPlay.Count == 0)
{
PlayMode = PlayerMode.None;
return;
}
//当前播放的Frames
BallGameObject.transform.localPosition = GetPosition(m_PassedFixedUpdate, m_RealTimeFrameInterval, m_FramesToPlay);
//如果到了Touch 点, 显示Touchpoint
ShowTouchPoint(m_PassedFixedUpdate, m_RealTimeFrameInterval, m_FramesToPlay, DataManager.Instance.CurTrackInfo.TrackIndex);
if (m_PassedFixedUpdate >= (m_TotalPlayTime - Mathf.Epsilon))
{
m_PassedFixedUpdate = 0f;
PlayMode = PlayerMode.None;
//播放结束, 摄像机动画
FinaliseHawkEyeCamera();
return;
}
SetHawkEyeCamera(m_PassedFixedUpdate, m_RealTimeFrameInterval, m_FramesToPlay);
m_PassedFixedUpdate += Time.fixedUnscaledDeltaTime;
Mathf.Clamp(m_PassedFixedUpdate, 0f, m_TotalPlayTime);
}
void OnJoinButtonClicked(PlayerMode mode)
{
if (UUID.Length == 0)
{
return;
}
if (Nickname.Length == 0)
{
return;
}
if (WorldID.Length == 0)
{
return;
}
this.mode = mode;
var p = new SignUpPacket(UUID);
var conn = ConnectionManager.Instance;
conn.SendImmediate(p);
// 중복 클릭 방지
joinPlayerButton.interactable = false;
joinObserverButton.interactable = false;
}
private void DisplayStage(PhaseEnum phase, PlayerMode playerMode)
{
StringBuilder sbStage = new StringBuilder();
switch (phase)
{
case PhaseEnum.ActionTreasure:
sbStage.Append("Action (Treasure)");
break;
case PhaseEnum.BuyTreasure:
sbStage.Append("Buy (Treasure)");
break;
default:
sbStage.Append(phase);
break;
}
switch (playerMode)
{
case PlayerMode.Playing:
case PlayerMode.Buying:
case PlayerMode.Choosing:
sbStage.AppendFormat(" - {0}", playerMode);
break;
}
lStage.Content = sbStage.ToString();
}
void OnTriggerEnter(Collider collider)
{
if (collider.gameObject.tag.GetHashCode() != ENEMY_HASH) return;
var enemy_stater = collider.gameObject.GetComponent<EnemyStater>();
if (!enemy_stater.isNormal) return;
var enemy_hp_manager = collider.gameObject.GetComponent<HPManager>();
if (!enemy_hp_manager.isActive) return;
if (player_mode_ != PlayerMode.NORMAL) return;
enemy_stater.SendHitPlayer(transform);
var direction = new Vector3(transform.forward.x, 0, transform.forward.z);
hit_position_ = collider.gameObject.transform.position + direction * MELEE_DISTANCE;
player_mode_ = PlayerMode.MELEE;
melee_manager_.SetActive(true);
for (int i = 0; i < 4; i++)
{
var effect = Instantiate(effect_);
var position = transform.position;
position.y += 2.0f;
effect.transform.position = position;
Destroy(effect, 4.0f);
}
rigidbody_.velocity = Vector3.zero;
rigidbody_.angularVelocity = Vector3.zero;
}
public void DeadTime()
{
if (time == null) return;
time.Update();
if (time.RemainTime <= 0) {
switch (type) {
case PlayerMode.Chase:
type = PlayerMode.Escape;
break;
case PlayerMode.Escape:
type = PlayerMode.Chase;
break;
default:
break;
}
foreach (Transform n in this.gameObject.transform) {
if (n.gameObject.tag == "Weapon") {
Destroy(n.gameObject);
}
}
pointFlag = false;
catchTrap = false;
killEnemy = false;
isChange = true;
time.Reset();
}
}
public Player(Texture2D texture, Vector2 position, int width, Color color, float rotation, float scale,
float drawLayer, int frames, Texture2D cannonTex, Texture2D planeTex, Texture2D transitionTex)
: base(texture, position, width, color, rotation, scale, drawLayer, frames)
{
cannon = new Sprite(cannonTex, this.Position + cannonOffset, cannonTex.Width, Color.White, 0, 1, this.DrawLayer - 0.01f, 1);
tank = texture;
plane = planeTex;
transition = transitionTex;
TankMoveRect = new Rectangle(
(int)Position.X,
Camera2D.ScreenRect.Height - maxTankMoveHeight,
Camera2D.ScreenRect.Width,
maxTankMoveHeight - this.Height / 2);
PlaneMoveRect = new Rectangle(
Camera2D.ScreenRect.X,
0,
Camera2D.ScreenRect.Width,
Camera2D.ScreenRect.Height - maxTankMoveHeight);
tankDropPos = new Vector2(this.Position.X, TankMoveRect.Y + maxTankMoveHeight / 2);
planeRisePos = new Vector2(this.Position.X, PlaneMoveRect.Height / 3);
oldPosition = cannonCentre;
mode = PlayerMode.Tank;
PlayerSpeed = 0;
ProjectileManager.CannonJustFired += new CannonFired(ProjectileManager_CannonJustFired);
HUD.LaunchMissiles += new FullyLocked(HUD_LaunchMissiles);
}
public bool Join(Session session, string nickname, PlayerMode mode)
{
if (session.WorldID != null)
{
return(false);
}
session.WorldID = ID;
session.Nickname = nickname;
sessions.Add(session);
var sessionID = session.ID;
if (mode == PlayerMode.Player)
{
var p = new Player(sessionID, session);
playerTable[sessionID] = PlayerHolder.FromPlayer(p);
return(true);
}
else if (mode == PlayerMode.Observer)
{
var o = new Observer(sessionID, session);
playerTable[sessionID] = PlayerHolder.FromObserver(o);
return(true);
}
// else...
return(true);
}
public void PlayeTrack(string roundID, int trackID, int length)
{
//获取最近的回合信息
RoundInfo roundInfo = DataManager.Instance.GetRoundInfo(roundID);
//获取轨迹信息
List <TrackInfo> trackInfoList = roundInfo.GetTargetTracksByIndex(trackID, length);
if (trackInfoList == null)
{
Debug.LogError("获取轨迹为空");
return;
}
if (EventManager.ShowTrackInfo != null)
{
EventManager.ShowTrackInfo(trackInfoList[0]);
}
//按照轨迹顺序 播放轨迹
ResetPlayingData();
for (int i = 0; i < trackInfoList.Count; i++)
{
TrackInfo info = trackInfoList[i];
m_FramesToPlay.AddRange(info.FrameInfos);
}
PlayMode = PlayerMode.PlayTrack;
//设置播放速度
m_RealTimeFrameInterval = DBFRAMETimeDelta / m_SpeedScale;
m_TotalPlayTime = (m_FramesToPlay.Count - 1) * m_RealTimeFrameInterval; //总播放时长
//CameraManager.Instance.SetHawkEyeCameraActive(false);
m_PlayingTrackList = trackInfoList;
}
//void ManageBools()
//{
// if (device0 != null)
// connected0 = true;
// else connected0 = false;
// if (device1 != null)
// connected1 = true;
// else connected1 = false;
//}
void ManageDevices()
{
var inputDevice = InputManager.ActiveDevice;
if (JoinButtonWasPressedOnDevice(inputDevice))
{
if (ServiceLocator.instance.controllerRefs.device0 == null && ServiceLocator.instance.controllerRefs.device1 == null)
{
ServiceLocator.instance.controllerRefs.device0 = inputDevice;
mode = PlayerMode.Single;
}
else if (ServiceLocator.instance.controllerRefs.device0 == null && ServiceLocator.instance.controllerRefs.device1 != null && ServiceLocator.instance.controllerRefs.device1 != inputDevice)
{
ServiceLocator.instance.controllerRefs.device0 = inputDevice;
mode = PlayerMode.Coop;
}
else if (ServiceLocator.instance.controllerRefs.device0 != null && ServiceLocator.instance.controllerRefs.device1 == null && ServiceLocator.instance.controllerRefs.device0 != inputDevice)
{
ServiceLocator.instance.controllerRefs.device1 = inputDevice;
mode = PlayerMode.Coop;
}
else if (ServiceLocator.instance.controllerRefs.device0 != null && ServiceLocator.instance.controllerRefs.device1 != null)
{
return;
}
}
}
public PlayerParameter()
{
ResetLevel ();
ResetLifePoint ();
ResetScore ();
mode = PlayerMode.NORMAL;
}
public void PlaceBlock(PlayerMode mode, Vector3 coords)
{
Debug.Log("Placing item in slot " + currentSlot + ".");
if (currentItem != null) //Check if its not null.
{
GameObject clone = null;
if (mode == PlayerMode.survival)
{
clone = CreateBlock(currentItem.gameObject, coords);
if (currentItem.getHowMany() > 1) //Check if its the last one in inventory. If not, keep copy in inventory.
{
currentItem.setHowMany(HowMany.increment, -1);
}
else //If so, use last one.
{
RemoveForPlacing(UISlotType.hotbar);
}
}
else if (mode == PlayerMode.creative)
{
clone = CreateBlock(currentItem.gameObject, coords);
}
Debug.Log("Placed " + clone.GetComponent <Item>().getItemName() + " at coordinates " + clone.transform.position);
}
else
{
Debug.Log("Placed nothing.");
}
}
private static bool ModeWait(PlayerMode mode, bool negate)
{
PC Me = new PC();
int count = 0;
if (mode == PlayerMode.TownNeutral)
{
mode = PlayerMode.Neutral;
}
if (negate)
{
while (Me.Mode == mode)
{
Thread.Sleep(10);
if (count++ > 100)
{
return(false);
}
}
return(true);
}
else
{
while (Me.Mode != mode)
{
Thread.Sleep(10);
if (count++ > 100)
{
return(false);
}
}
return(true);
}
}
public void AutoMoveStart(Direction.DirectionState dir)
{
//if (playerMode != PlayerMode.Nomal && playerMode != PlayerMode.Slashing)
// return;
if (dir == Direction.DirectionState.Up)
{
moveTargetPosition = transform.position + moveY;
}
if (dir == Direction.DirectionState.Down)
{
moveTargetPosition = transform.position - moveY;
}
if (dir == Direction.DirectionState.Right)
{
moveTargetPosition = transform.position + moveX;
}
if (dir == Direction.DirectionState.Left)
{
moveTargetPosition = transform.position - moveX;
}
playerMode = PlayerMode.AutoMoving;
}
private void UpdatePlayerDisplayAppearance(PlayerMode targetPlayerMode)
{
if (targetPlayerMode == PlayerMode.Unknown)
{
return;
}
// Set color to player display
Color playerColor = targetPlayerMode == PlayerMode.VR ? Color.green : Color.blue;
// If the player's camera is using, don't show the player mesh. Just display the shadow.
var shadowCastingMode = (isLocalPlayer || isBeingObserved) ? ShadowCastingMode.ShadowsOnly : ShadowCastingMode.On;
// If the player is observing other, completely hide the player display.
var isVisible = targetPlayerMode != PlayerMode.Observer;
foreach (MeshRenderer renderer in playerDisplay.GetComponentsInChildren <MeshRenderer>())
{
renderer.enabled = isVisible;
if (isVisible)
{
renderer.shadowCastingMode = shadowCastingMode;
}
}
playerColorObj.GetComponent <MeshRenderer>().material.SetColor("_EmissionColor", playerColor);
}
public PlayerStateInfo(PlayerState ps)
{
Condition = ps.Condition;
Mode = ps.Mode;
Comment = ps.Comment;
Score = ps.Score;
}
public override void Play(Player player)
{
this._CanCleanUp = true;
base.Play(player);
Choice choice = new Choice(String.Format("Choose an Action card to play twice", player), this, player.Hand[Cards.Category.Action], player);
ChoiceResult result = player.MakeChoice(choice);
if (result.Cards.Count > 0)
{
result.Cards[0].ModifiedBy = this;
player.Actions++;
PlayerMode previousPlayerMode = player.PutCardIntoPlay(result.Cards[0], String.Empty);
Card logicalCard = result.Cards[0].LogicalCard;
player.PlayCard(result.Cards[0].LogicalCard, previousPlayerMode);
player.Actions++;
previousPlayerMode = player.PutCardIntoPlay(result.Cards[0], "again");
player.PlayCard(logicalCard, previousPlayerMode);
this._CanCleanUp = logicalCard.CanCleanUp;
}
else
{
player.PlayNothing();
}
}
static async Task MultiPlayerStart(PlayerType playerType, PlayerMode playerMode)
{
try
{
var player = await _client.GetRandomPlayerAsync();
player.Type = playerType;
if (playerMode == PlayerMode.Waiter)
{
await _client.InsertReservationAsync(new Reservation { Player = player });
}
else
{
List <Reservation> reservations;
do
{
reservations = await _client.GetReservationsAsync();
await Task.Delay(TimeSpan.FromMilliseconds(500));
} while (reservations == null || reservations.Count < 1);
await _client.InsertGameStartAsync(new GameStart { Player1 = reservations[0].Player, Player2 = player });
System.Console.Write($"Playing game {reservations[0].Player.Name} vs. {player.Name} ...");
}
await PlayGameAsync(player, playerMode);
}
catch (Exception e)
{
LogEvent(playerMode, e.Message, ConsoleColor.DarkRed);
System.Console.WriteLine(e.Message);
}
}
// Use this for initialization
void Start()
{
if (m_controller == null)
{
Debug.Log("playerの親がアタッチされてないよ");
}
m_mode = m_controller.m_playerMode;
}
//状態変化
private void ChangeState(Collision collision, ref PlayerMode _changeOldStay)
{
//オブジェクトの判別はtagで行っているので、tag追加お願いします
//
//プレイヤーが火に触れた時の処理
if (collision.gameObject.tag == "Fire")
{
if (_playerMode == PlayerMode.WATER)
{
_changeOldStay = _playerMode;
_playerMode = PlayerMode.CHANGE;
_changeNewStay = PlayerMode.AIR;
_playerFreezePos = gameObject.transform.position;
}
else if (_playerMode == PlayerMode.ICE)
{
_changeOldStay = _playerMode;
_playerMode = PlayerMode.CHANGE;
_changeNewStay = PlayerMode.WATER;
_playerFreezePos = gameObject.transform.position;
}
}
//プレイヤーが氷に触れた時の処理
if (collision.gameObject.tag == "Ice")
{
if (_gravityMode)
{
if (_playerMode == PlayerMode.AIR)
{
_changeOldStay = _playerMode;
_playerMode = PlayerMode.CHANGE;
_changeNewStay = PlayerMode.WATER;
_playerFreezePos = gameObject.transform.position;
}
}
else
{
if (_playerMode == PlayerMode.WATER)
{
_changeOldStay = _playerMode;
_playerMode = PlayerMode.CHANGE;
_changeNewStay = PlayerMode.ICE;
_playerFreezePos = gameObject.transform.position;
}
}
}
}
void OnCollisionEnter(Collision collision)
{
if(collision.gameObject.tag=="World" && grounded == false){
grounded = true;
}
if(collision.gameObject.tag=="Rail" && playerMode == PlayerMode.Skate){
// if(this.transform.forward
transform.root.GetComponent<RailEngager>().spline =
collision.gameObject.GetComponent<RailComponent>().rail;
playerMode = PlayerMode.Grind;
grounded = true;
}
}
void Update()
{
if (!isLocalPlayer) return;
if (!isMeleeMode) return;
melee_time_ += Time.deltaTime;
var position = new Vector3(hit_position_.x, transform.position.y, hit_position_.z);
transform.position = position;
if (!(player_melee_attacker_.isThreeAttacked || melee_time_ >= 3.0f)) return;
rigidbody_.AddForce(-transform.forward * 50.0f, ForceMode.Impulse);
player_mode_ = PlayerMode.NORMAL;
melee_manager_.SetActive(false);
}
/// <summary>
/// Parameterized constructor
/// </summary>
/// <param name="pm">Window mode (PM_ADD is default)</param>
/// <param name="p"><see cref="Player"/> object</param>
public AddPlayerForm( PlayerMode pm = PlayerMode.PM_ADD, Player p = null)
{
InitializeComponent();
windowMode = pm;
if (pm == PlayerMode.PM_EDIT)
{
windowMode = PlayerMode.PM_EDIT;
this.buttonAddPlayer.Text = "OK";
player = p;
this.textBoxPlayerName.Text = p.Name;
this.textBoxPlayerMoney.Text = p.Money.ToString();
}
}
// Use this for initialization
void Start () {
mode = PlayerMode.Hover;
hoverMove.enabled = true;
flight.enabled = false;
animator.SetBool("Flying", false);
phys.WingColliderEnabled = false;
defaultDrag = phys.drag;
paused = false;
rotFromPhys = false;
spawnPos = transform.position;
spawnAngle = transform.rotation;
hoverMove.InitializeAngles(spawnAngle.eulerAngles.y);
}
private float tagAlpha = 0; //Alpha color value for nametags
#endregion Fields
#region Constructors
public Player(Map map, Vector2 position, string name, long RUI, int ID)
{
this.Map = map;
Smiley = SmileyType.Default;
Mode = PlayerMode.Normal;
Tint = Color.White;
SimulationState = new EntityState();
DisplayState = new EntityState();
PreviousState = new EntityState();
SimulationState.Position = PreviousState.Position = DisplayState.Position = position;
this.RUI = RUI;
this.ID = (byte)ID;
this.Username = name;
Index = map.Players.Count;
}
public EntityState SimulationState; //Current internal state (What the game sees)
#endregion Fields
#region Constructors
/// <summary>
/// Creates a new base of a player
/// </summary>
public Player(Map map, Vector2 position, string name, int id)
{
Map = map;
Smiley = SmileyType.Default;
Mode = PlayerMode.Normal;
Tint = Color.White;
SimulationState = new EntityState();
DisplayState = new EntityState();
PreviousState = new EntityState();
SimulationState.Position = PreviousState.Position = DisplayState.Position = position;
if (id > byte.MaxValue)
throw new ArgumentOutOfRangeException("id", id, "The player ID must be within range of a single byte.");
ID = (byte)id;
Username = name;
Index = map.Players.Count;
}
public void OnCollisionEnter(Collision collision)
{
//オブジェクトの判別はtagで行っているので、tag追加お願いします
//
//プレイヤーが火に触れた時の処理
if (collision.gameObject.tag == "Fire")
{
if (!(_playerMode == PlayerMode.AIR))
{
_playerMode = PlayerMode.AIR;
}
}
//プレイヤーが氷に触れた時の処理
if (collision.gameObject.tag == "Ice")
{
if (_gravityMode)
{
if (_playerMode == PlayerMode.AIR)
{
_playerMode = PlayerMode.WATER;
}
}
else
{
if (_playerMode == PlayerMode.WATER)
{
_playerMode = PlayerMode.ICE;
}
}
}
//プレイヤーが壊せる壁に触れた時の処理
if (collision.gameObject.tag == "BreakWall")
{
if (_playerMode == PlayerMode.ICE)
{
_playerMode = PlayerMode.WATER;
}
}
}
//状態変化
private void ChangeState(Collision collision)
{
//オブジェクトの判別はtagで行っているので、tag追加お願いします
//
//プレイヤーが火に触れた時の処理
if (collision.gameObject.tag == "Fire")
{
if (_playerMode == PlayerMode.WATER)
{
_playerMode = PlayerMode.CHANGE;
_changeStay = PlayerMode.AIR;
}
else if (_playerMode == PlayerMode.ICE)
{
_playerMode = PlayerMode.CHANGE;
_changeStay = PlayerMode.WATER;
}
}
//プレイヤーが氷に触れた時の処理
if (collision.gameObject.tag == "Ice")
{
if (_gravityMode)
{
if (_playerMode == PlayerMode.AIR)
{
_playerMode = PlayerMode.CHANGE;
_changeStay = PlayerMode.WATER;
}
}
else
{
if (_playerMode == PlayerMode.WATER)
{
_playerMode = PlayerMode.CHANGE;
_changeStay = PlayerMode.ICE;
}
}
}
}
public void SetPlayerMode(PlayerMode mode)
{
Debug.Log(playerNumber + ":" + mode);
mass = 100;
playerMode = mode;
Transform targetTransform = null;
foreach(Transform t in transform) {
if(playerMode == PlayerMode.Fighter && t.name == "Fighter(Clone)") {
targetTransform = t;
Debug.Log("Fighter On");
t.gameObject.SetActiveRecursively(true);
handler = (IInputHandler)t.GetComponent("IInputHandler");
}
else if(playerMode == PlayerMode.Turret && t.name == "Turret(Clone)") {
targetTransform = t;
Debug.Log("Turret On");
t.gameObject.SetActiveRecursively(true);
handler = (IInputHandler)t.GetComponent("IInputHandler");
t.transform.position = new Vector3(15,0,0);
t.transform.localEulerAngles = new Vector3(0,270,0);
}
else {
Debug.Log(t.name + " Off");
t.gameObject.SetActiveRecursively(false);
}
}
if(targetTransform != null) {
Camera c = MultiManager.Instance.GetCameraForPlayer(playerNumber);
if(c != null) {
SmoothFollow sf = c.GetComponent<SmoothFollow>();
if(sf == null) {
sf = c.gameObject.AddComponent<SmoothFollow>();
sf.player = this;
}
sf.target = targetTransform;
sf.distance = 3;
sf.rotationDamping = 15;
SmoothLookAt sla = c.GetComponent<SmoothLookAt>();
if(sla == null) {
sla = c.gameObject.AddComponent<SmoothLookAt>();
}
sla.target = targetTransform;
}
}
}
public void SetIntroMode(bool introMode) {
if (introMode) {
paused = true;
mode = PlayerMode.Intro;
cam.enabled = false;
leavesEffect.enabled = false;
speedEffect.SpeedEffectActive = false;
hoverMove.enabled = false;
flight.enabled = false;
} else {
paused = false;
cam.enabled = true;
cam.RunIntroRoutine();
leavesEffect.enabled = true;
speedEffect.SpeedEffectActive = true;
mode = PlayerMode.Stun;
StartCoroutine(ChangeMode(PlayerMode.Hover));
}
}
void OnTriggerEnter(Collider collider)
{
if (collider.gameObject.layer == LayerMask.NameToLayer("GameWater"))
{
Vector3 offset = new Vector3(0, 1, 0);
Instantiate(splashPrefab, transform.position + offset, transform.rotation);
Invoke("StopDeathCam", 0.25f);
AudioSource.PlayClipAtPoint(splashSound, transform.position);
velocity = Vector3.zero;
KillCharacter(false);
}
if (collider.gameObject.layer == LayerMask.NameToLayer("Hazard") && !_headStarting)
{
AudioSource.PlayClipAtPoint(skidSound, transform.position);
playerMode = PlayerMode.SLIPPING;
Debug.Log("Slipped!");
}
// Cornering
if (collider.gameObject.layer == LayerMask.NameToLayer("CornerTrigger"))
{
cornerPoint = collider.gameObject.transform.parent.position;
cornerPoint.y = transform.position.y;
if (playerMode == PlayerMode.RUNNING || playerMode == PlayerMode.CRASHING) // Avoid triggering multiple times
{
// Turning
switch (lg.cornerDirection)
{
case ProcGen.CornerDirection.LEFT:
if (autoTurn) { actionLeft = true; actionRight = false; }
anim.SetTrigger("LookLeft");
break;
case ProcGen.CornerDirection.RIGHT:
if (autoTurn) { actionRight = true; actionLeft = false; }
anim.SetTrigger("LookRight");
break;
}
}
playerMode = PlayerMode.TURNING;
}
}
void OnControllerColliderHit(ControllerColliderHit collision)
{
if (_headStarting && collision.gameObject.layer == LayerMask.NameToLayer("Obstacle")) {
disableGOs.Add(collision.gameObject);
Invoke("DisableGameObject", 0.05f);
}
if (sceneManager != null && collision.gameObject.CompareTag("Smashable") && !ragdolled)
{
if (playerMode == PlayerMode.CRASHING && !_headStarting)
{
return;
}
else if (drunkenness >= drunkSmashValue || _headStarting)
{
foreach (GameObject go in GetComponentInChildren<NearbyCrates>().CratesAhead)
{
go.SetActive(false);
}
AudioSource.PlayClipAtPoint(smackSound, transform.position);
if (!_headStarting)
{
SoberUp(drunkSmashValue);
prevMultiplier = multiplier;
multiplier = 1.0f;
}
Instantiate(smashPrefab, transform.position + (transform.forward * 3.0f), transform.rotation);
playerMode = PlayerMode.CRASHING;
if (!_headStarting)
StartCoroutine("CrateCrashing");
}
}
if (sceneManager != null && collision.gameObject.layer == LayerMask.NameToLayer("Obstacle") && !_headStarting)
{
if (collision.gameObject.CompareTag("Smashable") && playerMode == PlayerMode.CRASHING)
{
return;
}
AudioSource.PlayClipAtPoint(smackSound, transform.position);
KillCharacter(true);
}
if (jumping && !controller.isGrounded && collision.moveDirection.y < 0)
{
if (!ragdolled)
{
AudioSource.PlayClipAtPoint(landSound, transform.position);
anim.Play("Falling");
jumping = false;
}
}
if (collision.moveDirection.y < 0 && !jumping)
{
jumpVelocity = -0.1f;
}
}
IEnumerator CrateCrashing()
{
float timer = 0.0f;
Renderer[] allRenderers = GetComponentsInChildren<Renderer>();
foreach (Renderer r in allRenderers)
{
if (r)
{
if (r.material.HasProperty("_Color"))
{
Vector4 alpha = r.material.color;
alpha.w = 0.5f;
r.material.color = alpha;
}
}
}
for (int i = 0; i < 8; ++i) {
while (timer < 0.2f)
{
timer += Time.deltaTime;
yield return null;
}
timer = 0.0f;
foreach (Renderer r in allRenderers)
{
if (r)
{
if (r.gameObject.tag != "Parrot")
r.enabled = !r.enabled;
else if (_parrotActive)
r.enabled = !r.enabled;
}
}
}
foreach (Renderer r in allRenderers)
{
if (r)
{
if (r.material.HasProperty("_Color"))
{
Vector4 alpha = r.material.color;
alpha.w = 1.0f;
r.material.color = alpha;
}
if (r.gameObject.tag == "Parrot")
r.enabled = _parrotActive;
else r.enabled = true;
}
}
multiplier = prevMultiplier;
if (playerMode == PlayerMode.CRASHING)
playerMode = PlayerMode.RUNNING;
yield return null;
}
void Action()
{
switch (playerMode)
{
case PlayerMode.CRASHING:
case PlayerMode.RUNNING:
//if (_headStarting) return;
if (anim.speed > baseAnimSpeed) anim.speed = baseAnimSpeed;
if (actionLeft)
{
previousLane = currentLane;
currentLane--;
}
if (actionRight)
{
previousLane = currentLane;
currentLane++;
}
break;
case PlayerMode.TURNING:
if (anim.speed > baseAnimSpeed) anim.speed = baseAnimSpeed;
if (isTurning)
{
// Calculate curve
if (cornerStart == Vector3.zero)
{
cornerStart = transform.position;// cornerPoint + -transform.forward * Vector3.Distance(transform.position, cornerPoint);
}
turnTimer += (runSpeed * Time.deltaTime) / 10.0f;
// Position
Vector3 point1 = Vector3.Lerp(cornerStart, cornerPoint, turnTimer);
Vector3 point2 = Vector3.Lerp(cornerPoint, cornerEnd, turnTimer);
Vector3 pos = Vector3.Lerp(point1, point2, turnTimer);
pos.y = transform.position.y;
transform.position = pos;
// Rotation
//turnAngle = Mathf.LerpAngle(transform.rotation.y, turnDegree, turnTimer);
transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.Euler(0, turnDegree, 0), turnTimer);
// Stop Turning
if (turnTimer >= 1)
{
currentLane = 0;
laneVelocity = 0;
lanePosition = 0;
cornerStart = Vector3.zero;
cornerPoint = Vector3.zero;
cornerEnd = Vector3.zero;
turnTimer = 0;
isTurning = false;
//isTurning = false;
playerMode = PlayerMode.RUNNING;
//anim.Play("Walk");
}
}
if (actionLeft && !isTurning)
{
cornerEnd = cornerPoint + -transform.right * 4.5f;
turnDegree -= 90.0f;
isTurning = true;
}
if (actionRight && !isTurning)
{
cornerEnd = cornerPoint + transform.right * 4.5f;
turnDegree += 90.0f;
isTurning = true;
}
break;
case PlayerMode.SLIPPING:
if (anim.speed < baseAnimSpeed * 4) anim.speed = baseAnimSpeed * 4;
slipTimer += Time.deltaTime;
if (slipTimer >= slipDuration)
{
anim.speed = 1;
slipTimer = 0;
playerMode = PlayerMode.RUNNING;
}
break;
}
// Can always jump unless ragdolled
if (actionJump && !jumping)
{
AudioSource.PlayClipAtPoint(jumpSound, transform.position);
AudioSource.PlayClipAtPoint(deckSound, transform.position);
anim.Play("Jumping");
jumpVelocity = jumpSpeed;
jumping = true;
}
actionLeft = false;
actionRight = false;
actionJump = false;
}
public void ResetCharacter()
{
dead = false;
if (ragdolled)
{
ragdoll.ResetRagdoll();
ragdolled = false;
}
mainCamera.followPlayer = true;
mainCamera.deathCam = true;
transform.position = startingPosition;
transform.rotation = startingRotation;
currentLane = 0;
laneVelocity = 0;
lanePosition = 0;
cornerStart = Vector3.zero;
cornerPoint = Vector3.zero;
cornerEnd = Vector3.zero;
turnTimer = 0;
turnDegree = 0;
isTurning = false;
jumping = false;
jumpVelocity = 0.0f;
drunkenness = 0;
drunkTimer = 0;
slipTimer = 0;
prevDrunkenness = 0;
newDrunkenness = 0;
multiplier *= 0.75f;
if (multiplier < 1) {
multiplier = 1;
}
lg.RebuildMap();
anim.Play("Walk");
controller.enabled = true;
_gameManager.PlayerReset = true;
playerMode = PlayerMode.RUNNING;
ResetTouchData();
swiped = false;
mainCamera.ResetCam();
}
public void DeactivateHeadStart()
{
Time.timeScale = 1.0f;
_headStarting = false;
autoTurn = false;
playerMode = PlayerMode.RUNNING;
//ResetCharacter();
multiplier = 1.4f;
}
/// <summary>
/// Resets a player's hands.
/// </summary>
public void ResetHands()
{
IsActive = false;
PlayerMode = PlayerMode.Normal;
m_PlayerHandViewModel[0].ResetHand();
m_PlayerHandViewModel[1].ResetHand();
m_PlayerHandViewModel[2].ResetHand();
m_PlayerHandViewModel[3].ResetHand();
m_PlayerHandViewModel[0].HandMode = HandMode.Normal;
//m_PlayerHandViewModel[1].HandMode = HandMode.Normal;
//m_PlayerHandViewModel[2].HandMode = HandMode.Normal;
//m_PlayerHandViewModel[3].HandMode = HandMode.Normal;
}
/// <summary>
/// Splits a hand by removed a card from the current hand, creating another, and adding the removed card to the new hand.
/// </summary>
/// <param name="HandIndex">The index of the hand being split.</param>
public void Split(int HandIndex)
{
if (HandIndex != 3) {
if (PlayerMode == PlayerMode.Normal) {
PlayerMode = PlayerMode.SplitOnce;
} else if (PlayerMode == PlayerMode.SplitOnce) {
PlayerMode = PlayerMode.SplitTwice;
} else if (PlayerMode == PlayerMode.SplitTwice) {
PlayerMode = PlayerMode.SplitThrice;
}
for (int i = 0; i < 4; i++) {
if (PlayerHandVM[i].HandMode == HandMode.NotPlaying) {
PlayerHandVM[i].HandMode = HandMode.Normal;
PlayerHandVM[i].RecieveCard(PlayerHandVM[HandIndex].SplitHand());
PlayerHandVM[i].CanSurrender = false;
return;
}
}
} else {
throw new Exception("Can't split on the last hand. How did we get here?");
}
}
private IEnumerator ChangeMode(PlayerMode newMode) {
Debug.Log("Switching from " + mode + " to " + newMode);
PlayerMode oldMode = mode;
mode = newMode;
hoverMove.enabled = false;
flight.enabled = false;
animator.SetBool("Stun", false);
animator.SetBool("Flying", newMode == PlayerMode.Flight);
phys.WingColliderEnabled = (newMode == PlayerMode.Flight);
cam.Transition(transitionTime, newMode == PlayerMode.Flight);
float heading = (oldMode == PlayerMode.Flight ? flight.Heading : hoverMove.Heading);
yield return StartCoroutine(AlignRotation(heading));
if (newMode == PlayerMode.Flight) {
flight.InitializeHeading(heading);
flight.enabled = true;
phys.velocity = transform.forward * flightBurstSpeed;
} else {
Debug.Log("Starting hover mode");
hoverMove.InitializeAngles(heading);
hoverMove.enabled = true;
}
}
private void DisplayStage(PhaseEnum phase, PlayerMode playerMode)
{
StringBuilder sbStage = new StringBuilder();
switch (phase)
{
case PhaseEnum.ActionTreasure:
sbStage.Append("Action (Treasure)");
break;
case PhaseEnum.BuyTreasure:
sbStage.Append("Buy (Treasure)");
break;
default:
sbStage.Append(phase);
break;
}
switch (playerMode)
{
case PlayerMode.Playing:
case PlayerMode.Buying:
case PlayerMode.Choosing:
sbStage.AppendFormat(" - {0}", playerMode);
break;
}
lStage.Content = sbStage.ToString();
}
void ConditionalLootRope(Collider2D other)
{
if (other.transform.tag == "RopeObject"
&& haveRope == false
&& playerMode != PlayerMode.Snake)
{
_haveRope = true;
playerMode = PlayerMode.Rope;
GameObject.Destroy(other.gameObject);
}
}
void getSnake()
{
if (playerMode != PlayerMode.NotDetermined)
{
throw new Exception("getSnake() method should be called only when the player mode is not determined.");
}
playerMode = PlayerMode.Snake;
++killCount;
changeAllRopesToSnakes();
}
void getGhost()
{
if (playerMode != PlayerMode.NotDetermined)
{
throw new Exception("getGhost() method should be called only when the player mode is not determined.");
}
playerMode = PlayerMode.Snake;
++killCount;
haveGhostEffect = true;
changeAllRopesToSnakes();
changeAllGhostsToGhosts();
}
public void PlayCard(Card card, PlayerMode previousPlayerModeToRestore)
{
this.CurrentTurn.Played(card);
card.Play(this);
card.PlayFinished(this);
this.InPlay.Refresh(this);
if (CardPlayed != null)
{
CardPlayedEventArgs cpdea = new CardPlayedEventArgs(this, card);
CardPlayed(this, cpdea);
}
this.PlayerMode = previousPlayerModeToRestore;
}
private void setMode(PlayerMode newMode) {
if (newMode == mode) {
return;
} else {
StopAllCoroutines();
StartCoroutine(ChangeMode(newMode));
}
}
