//
void Awake()
{
// load
Nurture.Calendar calendar = loadCalendar();
_mainCharacter = loadMainCharacter(calendar);
loadAllStat(_mainCharacter);
Story.TargetCharacter targetCharacter = loadTargetCharacter();
// story
_storyMode = new Story.Mode(targetCharacter);
// nurture
_nurtureMode = new Nurture.Mode(calendar, _mainCharacter);
// board game
_boardGameMode = new BoardGame.BoardGameMode();
// combat
_combatMode = new Combat.CombatMode();
// events
_endNurtureEvent = new EndNurtureEvent();
// attach handler
NurtureMode.Schedule.EndEvent.Attach(onScheduleEnd);
}
public ActionResult BindPOVCharacterToScene(int?id)
{
var scene = db.Scenes.Find(PageManager.CurrentScene.ID);
MainCharacter mainCharacter = null;
if (id != null)
{
mainCharacter = db.MainCharacters.Find(id);
if (scene == null || mainCharacter == null)
{
return(HttpNotFound());
}
scene.POVCharacterId = mainCharacter.ID;
mainCharacter.POVScenes.Add(scene);
}
else
{
scene.POVCharacterId = null;
}
db.SaveChanges();
pc.RemovePage("PickOne", "MainCharacters");
return(RedirectToAction("Details", "Scenes", new { id = scene.ID }));
}
// StartConversationActions() is called by the conversation engine when a conversation begins.
// It is called via BroadcastMessage(), so you can add as many actions as necessary. These are just examples
public void StartConversationActions()
{
//Debug.Log("starting convo actions");
mPlayerRef = MainCharacter.Instance.gameObject;
//PauseMenu pm = mPlayerRef.GetComponent<PauseMenu>();
//pm.mConvoEnabled = true;
mMainCharacterRef = MainCharacter.Instance;
if (mStopMoving)
{
iTween.Pause(this.gameObject);
}
if(mTurnTowardsPlayer)
{
Vector3 playerPos = mPlayerRef.transform.position;
this.transform.LookAt(new Vector3(playerPos.x, this.transform.position.y, playerPos.z));
if(mReverseModel)
{
this.transform.Rotate(0, 180, 0);
}
}
/*if (mStopMoving == true)
{
iTween.Pause(this.gameObject);
}*/
}
protected override void Awake()
{
base.Awake();
current = this;
//EnsureSelectedWeaponIsAvailable();
StartCoroutine(DistantUnitsDisableRoutine());
}
public Level(Game1 game)
{
myGame = game;
currentLevel = game.currentLevel;
IsPaused = false;
mainCharacter = new MainCharacter(myGame, new Vector2(GameConstants.MainCharStartingX, GameConstants.MainCharStartingY));
}
void Start()
{
MainCharacter mainCharacter = Manager.Instance.Object.MainCharacter;
EConstitution constitution = mainCharacter.Constitution;
int constitutionId = (int)constitution;
Constitution c = Manager.Instance.DT.Constitution[constitutionId];
ConstitutionImage.sprite = c.sprite;
ConstitutionImage.color = c.color;
//setConstitutionText(get(constitution));
EZodiac zodiac = Manager.Instance.Object.NurtureMode.Character.Zodiac;
ZodiacImage.sprite = get(zodiac);
//setZodiacText(get(zodiac));
int age = mainCharacter.Age;
setAgeText(age);
string name = mainCharacter.Name;
setNameText(name);
Manager.Instance.Object.NurtureMode.Character.AgeChangeEvent.Attach(onAgeChanged);
}
private void Awake()
{
gameplayPaused = true;
Time.timeScale = timeScale;
playerChar = FindObjectOfType <MainCharacter>();
uIHandle = GetComponent <GameplayUIHandle>();
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MainCharacter mainCharacter = db.MainCharacters.Find(id);
if (mainCharacter == null)
{
return(HttpNotFound());
}
Session["destinedController"] = "MainCharacters";
if (PageManager.CurrentMainCharacter == null)
{
Session["destinedMethod"] = "Home";
}
else
{
Session["destinedMethod"] = "Details";
}
PageManager.CurrentMainCharacter = mainCharacter;
var propertyCount = 4;
return(pc.AddDeletePage("MainCharacters", mainCharacter, propertyCount));
}
public void BombItemCollision(Game1 game, MainCharacter mainCharacter, List <IItem> itemElements)
{
myGame = game;
foreach (IItem item in itemElements)
{
if (mainCharacter.bombItem.itemSprite.desRectangle.Intersects(item.itemSprite.desRectangle) && !(item.itemSprite is DiskSprite))
{
if (bombCount == 30)
{
mainCharacter.bombItem.isVisible = false;
bombCount = 0;
mainCharacter.bombUpdate = false;
}
else
{
item.gravity = 0;
mainCharacter.bombItem.canMove = false;
if (item is BadCowCharacter)
{
mainCharacter.BadCowCount++;
mainCharacter.GoalCount++;
item.itemSprite = CharacterSpriteFactory.Instance.CreateBadCowDeadSprite();
}
else
{
item.itemSprite = CharacterSpriteFactory.Instance.CreateDeadCowSprite();
}
mainCharacter.bombItem.itemSprite = CharacterSpriteFactory.Instance.CreateDeadUFOSprite();
}
bombCount++;
}
}
}
private void _on_MainCharacter_Death(MainCharacter mainCharacter)
{
GD.Print("Main character dieee");
Input.SetMouseMode(Input.MouseMode.Visible);
this.mainCharacter.uiGameOver.ShowDialog(this.mainCharacter.Kills, this.currentRound);
this.mainCharacter.canvasLayer.QueueFree();
}
private void OnBoundsReceived(BoundsMessage m)
{
Scene.QueueAction(() =>
{
if (m.ClientToUpdate == client.ClientId)
{
MainCharacter.MoveTo(m.X, m.Y);
MainCharacter.Speed.SpeedX = m.SpeedX;
MainCharacter.Speed.SpeedY = m.SpeedY;
}
else
{
var opponent = opponents.WhereAs <RemoteCharacter>().Where(o => o.RemoteClientId == m.ClientToUpdate).Single();
if (opponent != null)
{
Scene.QueueAction(() =>
{
opponent.MoveTo(m.X, m.Y);
opponent.Speed.SpeedX = m.SpeedX;
opponent.Speed.SpeedY = m.SpeedY;
});
}
}
});
}
CharacterHolder(User user)
{
this.mainUser = user;
this.mainCharacter = MainCharacter.CreateMainCharacter(user);
this.characters = new Dictionary<string, Character>();
//characters.Add(mainUser.Username, mainCharacter);
}
protected void TakeVehicle()
{
Camera camera = cameraObject.GetComponent <Camera>();
Ray camera_ray = camera.ViewportPointToRay(new Vector3(0.5f, 0.5f, 0.5f));
RaycastHit hit;
bool collision = Physics.Raycast(camera_ray, out hit);
if (collision && (hit.collider.gameObject.tag == "Vehicle") && hit.distance < 7)
{
GameObject vehicle = hit.collider.gameObject;
VehicleController controller = vehicle.GetComponent <VehicleController>();
MainCharacter character = this.GetComponent <MainCharacter>();
controller.enabled = true;
character.enabled = false;
transform.parent = vehicle.transform;
transform.position = vehicle.transform.Find("DriverPosition").position;
transform.rotation = vehicle.transform.Find("DriverPosition").rotation;
GetComponent <CapsuleCollider>().enabled = false;
GetComponent <Rigidbody>().isKinematic = true;
//Swaping cameras
cameraObject.SetActive(false);
vehicle.transform.Find("Camera").gameObject.SetActive(true);
SetPistol();
Drive();
}
}
public override void Fire(MainCharacter MC, ProjectileManager PM, MouseState MS, GameTime GT)
{
MC.ShootTimeCounter += (float)GT.ElapsedGameTime.TotalSeconds;
if ((MC.ShootTimeCounter >= ShotTime) & (MS.LeftButton.Equals(ButtonState.Pressed)))
{
MC.ShootTimeCounter = 0.0f;
Projectile TempProj = new Projectile();
TempProj.Type = Get(MC.CurrentProjectileType);
TempProj.Speed = TempProj.Type.LaunchSpeed;
TempProj.Damage = TempProj.Type.Damage;
TempProj.Origin = TempProj.Type.InitialOrigin;
Vector2 Temp;
if (MC.Aimed)
{
Temp = Vector2.Transform(AimGunEnd, Matrix.CreateRotationZ(MC.Angle));
}
else
{
Temp = Vector2.Transform(GunEnd, Matrix.CreateRotationZ(MC.Angle));
}
TempProj.Position = MC.MapPosition + Temp;
if (MC.Aimed)
{
TempProj.Angle = MC.Angle;
}
else
{
TempProj.Angle = MC.Angle + (float)(Rand.NextDouble() * 0.16 - 0.08);
}
PM.Projectiles.Add(TempProj);
}
}
public EventScript(MainCharacter mainCharacter, ContentManager content, string text)
{
this.EndOfLine = false;
this.TextEnd = false;
TxtReader = new TxtReader(mainCharacter, content, text);
}
public void Reset(GameEngine gameEngine, MainCharacter mainCharacter, ContentManager content)
{
content.Unload();
MainCharacter = mainCharacter;
Content = content;
Arial = content.Load <SpriteFont>("Fonts/Arial");
// Initialize buttons
StartButtonImg = Content.Load <Texture2D>("start");
ExitButtonImg = Content.Load <Texture2D>("exit");
LoadingTxt = Content.Load <Texture2D>("loading");
float StartX = (Game1.GetWindowSize().X / 2) - (StartButtonImg.Width / 2);
float StartY = Game1.GetWindowSize().Y / 3;
float ExitX = (Game1.GetWindowSize().X / 2) - (ExitButtonImg.Width / 2);
float ExitY = 2 * Game1.GetWindowSize().Y / 3;
float LoadingX = (Game1.GetWindowSize().X / 2) - (LoadingTxt.Width / 2);
float LoadingY = (Game1.GetWindowSize().Y / 2) - (LoadingTxt.Height / 2);
StartButton = new ClickableTexture(StartButtonImg, new Vector2(StartX, StartY));
ExitButton = new ClickableTexture(ExitButtonImg, new Vector2(ExitX, ExitY));
LoadingTxtPos = new Vector2(LoadingX, LoadingY);
// important to reset these components to null when the manager is reloaded
KeyboardInputMenu = null;
GState = StartupState.StartMenu;
MouseState = Mouse.GetState();
PrevMouseState = MouseState;
}
public short CollideWeaponsWithEnemies(MainCharacter mainCharacter)
{
short result = 0;
int i = 0, j;
bool weaponDestroyed;
while (i < mainCharacter.Weapons.Count)
{
j = 0;
weaponDestroyed = false;
while (j < Enemy.Count && !weaponDestroyed)
{
if (mainCharacter.Weapons[i].CollidesWithImageShoot(Enemy[j].SpriteImage))
{
mainCharacter.RemoveWeapon(i);
Enemy.RemoveAt(j);
weaponDestroyed = true;
result += global::Enemy.DESTROY_SCORE;
}
else
{
j++;
}
}
if (!weaponDestroyed)
{
i++;
}
}
return(result);
}
public override void _Ready()
{
this.mainCharacter = GetNode <MainCharacter>("MainCharacter");
this.mainCharacter.Connect(nameof(MainCharacter.MainCharacterDie), this, "_on_MainCharacter_Death");
this.InitializeSpawn();
this.StartNextRound();
}
protected override void Initialize()
{
Graphics.PreferredBackBufferWidth = DEFAULT_WIDTH;
Graphics.PreferredBackBufferHeight = DEFAULT_HEIGHT;
Graphics.ApplyChanges();
WindowSize = new Point(Graphics.GraphicsDevice.Viewport.Width, Graphics.GraphicsDevice.Viewport.Height);
String path = Path.Combine(Content.RootDirectory, "savedata.txt");
String LoadDataJSON = File.ReadAllText(path);
if (LoadDataJSON.Equals(String.Empty))
{
MainCharacter = new MainCharacter();
}
else
{
MainCharacter = JsonSerializer.Deserialize <MainCharacter>(LoadDataJSON);
} String CharJSON = File.ReadAllText(path);
IsMouseVisible = true;
MainEngine.Push(new StartupManager(), false, false);
base.Initialize();
}
public virtual void Draw(Vector2 a_offset)
{
_tiledBackground.Draw(Vector2.Zero);
_grid.DrawGrid(_offset, "BackgroundLayer");
MainCharacter.Draw(_offset);
foreach (Projectile proj in _projectiles)
{
proj.Draw(_offset);
}
foreach (Projectile proj in _enemyProjectiles)
{
proj.Draw(_offset);
}
foreach (Npc npc in _npcs)
{
npc.Draw(_offset);
}
_grid.DrawGrid(_offset, "TileLayer");
foreach (Effect effect in _effects)
{
effect.Draw(_offset);
}
_ui.Draw(this);
}
public void MainCharItemCollision(MainCharacter mainCharacter, List <IItem> itemElements)
{
foreach (IItem item in itemElements)
{
if ((item is CowCharacter || item is BadCowCharacter) && mainCharacter.state.Sprite.desRectangle.Intersects(item.itemSprite.desRectangle) && mainCharacter.state.beam && item.isVisible)
{
if (item is CowCharacter)
{
myGame.level.mainCharacter.GoodCowCount++;
UFOSoundManager.instance.playSound(UFOSoundManager.COW);
}
else
{
mainCharacter.canMove = false;
mainCharacter.UFODie();
}
item.isVisible = false;
}
else if (item is Disk && mainCharacter.state.Sprite.desRectangle.Intersects(item.itemSprite.desRectangle) && item.isVisible)
{
Sound.MenuMusic.SoundList.instance.addMusic();
item.isVisible = false;
}
}
}
public override void Attack()
{
if (debugOptions.demilitarizedEnemies)
{
return;
}
MainCharacter mainCharacter = FindObjectOfType <MainCharacter>();
if (!mainCharacter)
{
return;
}
Vector2 attackVelocity;
if (aiming)
{
Vector2 mainCharacterPosition = FindObjectOfType <MainCharacter>().transform.position;
Vector2 aimedDirection = mainCharacterPosition - (Vector2)attackPoint.transform.position;
aimedDirection.Normalize();
attackVelocity = aimedDirection * projectileVelocity.magnitude;
}
else
{
attackVelocity = projectileVelocity;
}
GameObject newShot = Instantiate(attack, attackPoint.transform.position, Quaternion.identity);
newShot.GetComponent <Rigidbody2D>().velocity = attackVelocity;
}
public int GetSize(MainCharacter MC)
{
int Size;
Size = (int)(Distance * 0.15) + 10;
return(Size);
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
orfeo = new MainCharacter();
caronte = new Character();
p1 = new Passage(firstCP, caronteEntityState, 2);
p1.addLine(new Line(orfeo, "Parla orfeo"), 0);
p1.addLine(new Line(caronte, "parla caronte"), 1);
p2 = new Passage(null, caronteEntityState, 0);
firstCP = new ChoosePassage(2);
firstCP.addPassage(p1,0);
firstCP.addLine(new Line(orfeo, "parla di qualcosa"), 0);
firstCP.addPassage(p2, 1);
firstCP.addLine(new Line(orfeo, "esci dal dialogo"), 1);
caronteDialogue = new Dialogue(firstCP);
caronteState = new State();
caronteState.lineLookAt = new Line(caronte, "caronte -> lookat");
caronteState.linePickUp = new Line(caronte, "caronte -> pickup");
caronteState.dialogue = caronteDialogue;
caronteEntityState = new EntityState(1);
caronteEntityState.states[0] = caronteState;
caronteEntityState.currentState = caronteState;
caronte.entityState = caronteEntityState;
base.Initialize();
}
private void Awake()
{
if (Instance != null)
{
Destroy(Instance.gameObject);
}
Instance = this;
}
public void Init(MainCharacter _mainCh, SpriteRenderer _mainGraphic)
{
mainCh = _mainCh;
spriteRend = _mainGraphic;
lineRend = GetComponent <LineRenderer>();
lineRend.startColor = Color.gray;
DisplayTrajectory = false;
}
void OnCollisionEnter(Collision colInfo)
{
if (colInfo.gameObject.CompareTag("Player"))
{
m_MCharacter = colInfo.gameObject.GetComponent <MainCharacter> (); //Get main character script
m_MCharacter.TakeDamage(6); //PROVISIONAL (REPRODUCIR SONIDO)
}
}
void OnCollisionStay(Collision colInfo)
{
if (colInfo.gameObject.CompareTag("Player"))
{
m_MCharacter = colInfo.gameObject.GetComponent <MainCharacter> ();
m_MCharacter.TakeDamage(1); //PROVISIONAL (REPRODUCIR SONIDO)
}
}
public Form1()
{
InitializeComponent();
this.Size = new Size(1280, 720);
Samurai = new MainCharacter();
this.Controls.Add(Samurai.box);
}
string generate_abandoned(MainCharacter mc, Relic rel, string minions, string god, string title)
{
string s = "The " + rel.adjective + " " + rel.item + " was left in " + title + ", in a truly desperate attempt to prevent the " + rel.curse + ". ";
s += "It is watched over by the " + minions + " of " + god;
s += ". It remains there to this day. ";
return(s);
}
void attackHero(MainCharacter main)
{
if (Time.time - timeSinceLastAttack >= attackSpeed)
{
timeSinceLastAttack = Time.time;
main.takeDamage(attack);
}
}
string generate_horrible(MainCharacter mc, Relic rel)
{
string s = "Tragically, like it was too late for the crew, it was too late for that " + mc.adjective + " " + mc.name + ", even after " + mc.he + " had abandoned the " + rel.item + ". ";
s += "The famous " + mc.occupation + " was " + rel.cursed + " by a fate more horrible than any of the fates spoken of in the legends. ";
s += mc.name + " was " + rel.cf + " by the " + rel.minions + " of " + rel.owner + ". ";
return(s);
}
/* The branching story:
* Advanture can lead to being: (generate_opening) COMPLETE
* cursed, which leads to: (generate_cursed). COMPLETE
* All the men die, you die of old age. (generate_old)
* Or, you die too, a horrible death somehow. (generate_horrible)
* In either case, the treasure is abandoned somewhere.Which leads to the end state. (generate_abandoned).
* scorned, all your crew turns on you. Which leads to: (generate_scorned)
* You are killed, and the treasure is taken. By your crew. (generate_killed)
* Or, they leave you stranded to die somehwere. (generate_stranded)
* In Either case, the crew utlimately kill each other, leaving the treasure somewhere along the route home. Which leads to the end state. (generate_lost).
*/
string generate_opening(MainCharacter mc, Relic rel)
{
string s = "The great " + mc.adjective + " " + mc.occupation + " " + mc.name + " was noted for discovering the " + mc.history;
s += ". However, " + mc.his + " forgotten discovery was the discovery of the " + rel.adjective + " " + rel.item + " of " + rel.owner + ". ";
s += "This is not the tale of that discovery, but of what befell " + mc.him + " after... ";
return(s);
}
public void Start()
{
character = CharacterHolder.Instance.MainCharacter;
character.Show = true;
character.MovementManager.Enable(true);
character.EnableCamera(true);
character.EnterPublicWorld(false);
character.rigidbody.useGravity = false;
}
void StopConversationActions()
{
//Debug.Log("stopping convo actions");
mPlayerRef = MainCharacter.Instance.gameObject;
mMainCharacterRef = MainCharacter.Instance;
if(mMainCharacterRef.IsDetected()) { mMainCharacterRef.SetDetected(false); }
if(mStopMoving) { iTween.Resume(this.gameObject); }
}
public static void MoveUp(Characters enemy, MainCharacter mainCharacter, ref bool reachMainCharacther)
{
if (mainCharacter.Y + (mainCharacter.CurrentAnimation.FrameHeight - enemy.CurrentAnimation.FrameHeight) < enemy.Y)
{
enemy.CurrentAnimation = enemy.CurrentAnimation == enemy.WalkingLeft ? enemy.WalkingLeft : enemy.WalkingRight;
reachMainCharacther = true;
enemy.Y -= 1;
}
}
public static void MoveRight(Characters enemy, MainCharacter mainCharacter, ref bool reachMainCharacther)
{
if (mainCharacter.X - 50 < enemy.X)
{
enemy.X -= 1;
reachMainCharacther = true;
enemy.CurrentAnimation = enemy.WalkingLeft;
}
}
public void Start()
{
character = CharacterHolder.Instance.MainCharacter;
character.transform.position = spawn.position;
character.transform.rotation = Quaternion.identity;
character.Show = true;
character.MovementManager.Enable(true);
character.EnableCamera(true);
character.EnterPublicWorld(true);
}
void Start()
{
character = CharacterHolder.Instance.MainCharacter;
character.EnableCamera(false);
character.MovementManager.Enable(false);
serverView = GameObject.Find("Main").GetComponent<NetworkView>();
playersSelection = new List<SumoGamePlayerInfo>();
//ballScriptManager = GameObject.Find("GameManager").GetComponent<BallManagerScript>();
GameObject.DontDestroyOnLoad(gameObject);
}
public virtual void Awake()
{
if(_instance == null)
{
_instance = this as MainCharacter;
}
else
{
Debug.Log("Cannot have two instances of " + typeof(MainCharacter).ToString() + " : " + _instance);
Destroy(this.gameObject);
}
}
public override void Start()
{
base.Start(); // Make sure to call this first
GameObject temp = GameObject.FindGameObjectWithTag("MainCamera");
if(temp != null)
{
characterRef = temp.GetComponentInChildren<MainCharacter>();
BuildOk = SetupPlanes();
mDisplayPlaneOne.renderer.material = PlayerFace;
mDisplayPlaneTwo.renderer.material = CoveredFace;
}
}
public void Attached(MainCharacter mainCharacter)
{
if (Creature.AudioSource != null && Creature.BarkSounds != null) {
if (!Creature.AudioSource.enabled) Creature.AudioSource.enabled = true;
Creature.AudioSource.pitch = Random.Range(Creature.MinPitch, Creature.MaxPitch);
int random = (int)Random.Range(0.0f, Creature.BarkSounds.Length - 1);
Creature.AudioSource.PlayOneShot(Creature.BarkSounds[ random ]);
}
Shadow.SetActive(false);
foreach(DogTrait trait in Traits){
trait.OnAttach (mainCharacter);
}
}
public virtual void Start()
{
character = CharacterHolder.Instance.MainCharacter;
character.transform.position = characterSpawn.position;
character.transform.rotation = Quaternion.identity;
character.Show = true;
//character.MovementManager.Enable(false);
//character.EnableNetwork(false);
//character.EnableCamera(false);
/*if(MavaruOnlineMain.GameStateManager.State == GameStateManager.GameState.IN_FRIENDS_HOUSE){
friend = CharacterHolder.Instance.GetCharacter(MavaruOnlineMain.DatabaseManager.FriendUser);
friend.transform.position = friendSpawn.position;
friend.transform.rotation = Quaternion.identity;
friend.Show = true;
friend.MovementManager.Enable(false);
}*/
}
public static void Move(Characters enemy,MainCharacter mainCharacter)
{
bool reachMainCharacther=false;
MoveLeft(enemy, mainCharacter, ref reachMainCharacther);
MoveRight(enemy, mainCharacter, ref reachMainCharacther);
MoveDown(enemy, mainCharacter, ref reachMainCharacther);
MoveUp(enemy, mainCharacter, ref reachMainCharacther);
if (!reachMainCharacther)
{
enemy.CurrentAnimation.SourceRectangle = new Rectangle(0, 0, enemy.CurrentAnimation.FrameWidth,
enemy.CurrentAnimation.FrameHeight);
}
}
Inbox(Idol owner)
{
Owner = owner;
}
// Use this for initialization
//******************************************************************
void Start()
{
//Debug.Log("Starting Item: " + mItemName);
//rigidbody.isKinematic = true;
mPlayerRef = MainCharacter.Instance.gameObject;
mMainCharacterRef = MainCharacter.Instance;
mIsEquippable = true;
mIsDrawingHover = false;
mDrawInventoryIcon = false;
Inputbase.Instance.OnActionButtonPressedHandle += OnActionPressed;
gameObject.tag = "InteractiveItem";
//Debug.Log("Registering: " + mItemName);
GameManager.Instance.RegisterItem(mItemName.ToString(), this);
Physics.IgnoreCollision(collider,MainCharacter.Instance.collider);
}
private static bool CheckPlayerWin(string CharacterAccused, string item1, string item2, Motive motive)
{
bool accusedIsInList = false;
if(mPlayerRef == null)
{
mPlayerRef = GameObject.FindGameObjectWithTag("MainCamera").GetComponent<MainCharacter>();
}
foreach(NonPlayableCharacter character in Characters.Values)
{
if(character.CharacterSuspicion >= mPlayerRef.CharacterSuspicion - maxModifier && character.mCharacterName.ToString() == CharacterAccused)
{
Debug.Log(character.mCharacterName + " has more suspicion than the player");
if(!charSuspicion.ContainsKey(character))
charSuspicion.Add(character, character.CharacterSuspicion);
if(!characters.ContainsKey(character.mCharacterName.ToString()))
characters.Add(character.mCharacterName.ToString(), character.CharacterSuspicion);
}
}
foreach(var scopedCharacters in charSuspicion)
{
if(scopedCharacters.Key.mCharacterName.ToString() == CharacterAccused)
{
accusedIsInList = true;
Debug.Log(scopedCharacters.Key.mCharacterName + " is the person being framed");
accusedCharacter = scopedCharacters.Key;
}
}
if(!accusedIsInList)
return false;
var charComponent = GameManager.Instance.Characters[CharacterAccused];
var npcComponent = charComponent as NonPlayableCharacter;
if(npcComponent == null)
return false;
if(item1 == npcComponent.Item1.ToString() || item1 == npcComponent.Item2.ToString())
{
Debug.Log(accusedCharacter.mCharacterName + ": matched the first item, 5 points!");
accusedCharacter.ModifySuspicion(item1Modifier);
}
else
{
mPlayerRef.ModifySuspicion(item1Modifier);
}
if(item2 == npcComponent.Item1.ToString() || item2 == npcComponent.Item2.ToString())
{
Debug.Log(accusedCharacter.mCharacterName + ": matched the second item, 5 points!");
accusedCharacter.ModifySuspicion(item2Modifier);
}
else
{
mPlayerRef.ModifySuspicion(item2Modifier);
}
if(motive == npcComponent.mCharacterMotive)
{
Debug.Log(accusedCharacter.mCharacterName + ": matched the motive, 10 points!");
accusedCharacter.ModifySuspicion(motiveModifier);
}
else
{
mPlayerRef.ModifySuspicion(motiveModifier);
}
if(mPlayerRef.CharacterSuspicion < accusedCharacter.CharacterSuspicion)
{
return true;
}
else
{
return false;
}
}
public void Start()
{
mPlayerRef = GameObject.FindGameObjectWithTag("MainCamera").GetComponent<MainCharacter>();
}
public static void Destroy()
{
Destroy(Instance.gameObject);
_instance = null;
}
// Use this for initialization
void Start()
{
platformClient =gameObject.GetComponent<PlatformGameClient>();
gameReady = false;
character = CharacterHolder.Instance.MainCharacter;
character.transform.rotation = Quaternion.identity;
character.Show = true;
character.MovementManager.Enable(true);
character.EnableCamera(false);
character.transform.position = GameObject.Find("Spawn").transform.position;
//character.cameras[character.CurrentCamera].enabled = false;
character.EnterPublicWorld(true);
character.rigidbody.useGravity = true;
turn = 0;
round = 1;
settingPlatformsTime = 2f;
settingFlagTime = 1f;
settingPlatformsWhiteTime = 1f;
movingPlatformsTime = 4f;
//colorsForRound = new Dictionary<int, List<Color>>();
platformsSet = false;
randomColorIndex = -1;
flag = GameObject.Find ("Flag");
flagChanged = false;
//colors = new Color[platformCounter];
platforms = new GameObject[platformCounter];
//indexes = new List<int> ();
character = CharacterHolder.Instance.MainCharacter;
character.gameObject.AddComponent("CharacterScript");
colorsReady = false;
SetupPlatforms();
SetCharacters();
if (coroutine1 == null) {
coroutine1 = StartCoroutine (ChangeTexture ());
}
}
void Awake()
{
sounds = GetComponent<MedrashSounds>();
runningEnemy = GameObject.FindGameObjectWithTag("Fugitive");
pauseMenu = GameObject.FindGameObjectWithTag("MainCamera").GetComponent<PauseMenu>();
moveDirection = transform.TransformDirection(Vector3.forward);
mainCharacter = GetComponent<MainCharacter>();
animation = GetComponent<Animation>();
if(!animation) Debug.Log("The character you would like to control doesn't have animations. Moving her might look weird.");
if(!idle1Animation)
{
animation = null;
Debug.Log("No idle 1 animation found. Turning off animations.");
}
if(!idle2Animation)
{
animation = null;
Debug.Log("No idle 2 animation found. Turning off animations.");
}
if(!idle3Animation)
{
animation = null;
Debug.Log("No idle 3 animation found. Turning off animations.");
}
if(!walkAnimation)
{
animation = null;
Debug.Log("No walk animation found. Turning off animations.");
}
if(!walkSlowAnimation)
{
animation = null;
Debug.Log("No walk slow animation found. Turning off animations.");
}
if(!runAnimation)
{
animation = null;
Debug.Log("No run animation found. Turning off animations.");
}
if (!attack1Animation)
{
animation = null;
Debug.Log("No attack animation found. Turning off animations.");
}
if (!attack12Animation)
{
animation = null;
Debug.Log("No attack12 animation found. Turning off animations.");
}
if (!attack123Animation)
{
animation = null;
Debug.Log("No attack123 animation found. Turning off animations.");
}
if (!death1Animation)
{
animation = null;
Debug.Log("No death 1 animation found. Turning off animations.");
}
if (!death2Animation)
{
animation = null;
Debug.Log("No death 2 animation found. Turning off animations.");
}
if (!receiveAttackAnimation)
{
animation = null;
Debug.Log("No receive attack animation found. Turning off animations.");
}
if (!evadeLeftAnimation)
{
animation = null;
Debug.Log("No evade left animation found. Turning off animations.");
}
if (!evadeRightAnimation)
{
animation = null;
Debug.Log("No evade right animation found. Turning off animations.");
}
if (!evadeBackAnimation)
{
animation = null;
Debug.Log("No evade back animation found. Turning off animations");
}
if (!danceAnimation)
{
animation = null;
Debug.Log("No dance animation found. Turning off animations");
}
if (!fightStanceAnimation)
{
animation = null;
Debug.Log("No fight stance animation found. Turning off animations.");
}
if (!runFastAnimation)
{
animation = null;
Debug.Log("No run fast animation found. Turning off animations.");
}
attackDuration = baseAttackDuration/attack1AnimationSpeed;
delayAttackValue = attackDuration;
attackCooldownValue = delayAttackValue*1.5f;
StartCoroutine(FixPositionRelativeToEntities());
StartCoroutine(ComboVerification());
StartCoroutine(ChangeIdleActivity());
}
// Use this for initialization
void Start()
{
spriteRenderer = GetComponent<SpriteRenderer>();
m_collider = GetComponent<BoxCollider2D>();
mainCharacter = GameObject.Find("Main Character").GetComponent<MainCharacter>();
}
void Start()
{
character = CharacterHolder.Instance.MainCharacter;
character.transform.position = Vector3.zero;
character.transform.rotation = Quaternion.identity;
character.Show = true;
//character.EnableCamera(false);
//character.MovementManager.Enable(false);
//character.EnableNetwork(false);
}
//****************************************************************************
//****************************************************************************
void Start()
{
//mDoors = GameObject.FindGameObjectsWithTag("Door");
var body = gameObject.AddComponent<Rigidbody>();
body.isKinematic = true;
body.useGravity = false;
GameObject temp = GameObject.FindGameObjectWithTag("MainCamera");
if(temp != null)
{
characterRef = temp.GetComponentInChildren<MainCharacter>();
}
base.Start();
mCharacterMotive = MotiveManager.GetMotive(mCharacterName);
mConversationRef = gameObject.GetComponent<Conversation>();
//Debug.Log(gameObject.name + " Conversation status: " + mConversationRef);
mNavController = gameObject.GetComponent<Navigation>();
GameManager.Instance.RegisterMotive(mCharacterName.ToString(),mCharacterMotive);
GameManager.Instance.SpawnItem(Item1);
GameManager.Instance.SpawnItem(Item2);
mCaught1 = Conversation.LoadConvo(mCaughtItem1Convo);
mCaught2 = Conversation.LoadConvo(mCaughtItem2Convo);
mDefault = Conversation.LoadConvo(mDefaultConvo);
DiarySpawner.SpawnDiary(mCharacterName.ToString());
Inputbase.Instance.OnActionButtonPressedHandle += StartConverstaion;
mAnimationRef = GetComponentInChildren<Animation>();
if(gameObject.GetComponent<AccusePlayerInteraction>() != null)
{
mAnimationRef.Play(mIdleAnimation);
}
else
mAnimationRef.Play(mWalkAnimation);
//Debug.Log("Animation ref status: " + mAnimationRef);
}
public virtual void OnAttach(MainCharacter mainCharacter)
{
Debug.Log ("OnAttach not implemented");
}
public override void OnAttach(MainCharacter mainCharacter)
{
_levelGen = mainCharacter.GameController.LevelGeneration;
_closestDogLoc = new Vector3(1000.0f, 1000.0f, 1000.0f);
ExclamationSprite.SetActive(true);
}
// Use this for initialization
public virtual void Start()
{
m_collider = GetComponent<Collider2D>();
m_rigid = GetComponent<Rigidbody2D>();
m_mainCharacter = GameObject.Find("Main Character").GetComponent<MainCharacter>();
}
//******************************************************************
private void Start()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(this);
return;
}
mIsItemEquipped = false;
Conversation.OnConversationStarted += DisableClicking;
Conversation.OnConversationEnded += EnableClicking;
GameManager.OnGamePaused += DisableClicking;
GameManager.OnGameResume += EnableClicking;
GameManager.OnGameEnding += DisableClicking;
GameManager.OnGameCancelEnd += EnableClicking;
mCharacterName = CharacterName.MainCharacter;
Screen.showCursor = false;
//Screen.lockCursor = false;
}
