epic/OpenRA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make Conquest- and StrategicVictoryConditions use objectives backend

Browse Source 
Note: 3rd party KotH maps will need to be modified to work correctly
with this change.  Previously, StrategicVictoryConditions was a
supplement to ConquestVictoryConditions.  After this change, each works
by itself.  So KotH maps will need to remove the ConquestVictoryConditions
trait from the player definitions, or both victory conditions will have
to be satisfied to win the game.
This commit is contained in:
Oliver Brakmann
2014-07-25 09:25:32 +02:00
parent a3bf3e7403
commit 6e3000ab0e
7 changed files with 125 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
OpenRA.Mods.RA/ConquestVictoryConditions.cs
View File

@@ -13,80 +13,79 @@ using OpenRA.Traits;
namespace OpenRA.Mods.RA
{
public class ConquestVictoryConditionsInfo : ITraitInfo
public class ConquestVictoryConditionsInfo : ITraitInfo, Requires<MissionObjectivesInfo>
{
[Desc("Milliseconds")]
[Desc("Delay for the end game notification in milliseconds.")]
public int NotificationDelay = 1500;
public object Create(ActorInitializer init) { return new ConquestVictoryConditions(init.world, this); }
public object Create(ActorInitializer init) { return new ConquestVictoryConditions(init.self, this); }
}
public class ConquestVictoryConditions : ITick, IResolveOrder
public class ConquestVictoryConditions : ITick, IResolveOrder, INotifyObjectivesUpdated
{
ConquestVictoryConditionsInfo Info;
public ConquestVictoryConditions(World world, ConquestVictoryConditionsInfo info)
readonly ConquestVictoryConditionsInfo info;
readonly MissionObjectives mo;
int objectiveID = -1;
public ConquestVictoryConditions(Actor self, ConquestVictoryConditionsInfo cvcInfo)
{
world.ObserveAfterWinOrLose = true;
Info = info;
info = cvcInfo;
mo = self.Trait<MissionObjectives>();
}
public void Tick(Actor self)
{
if (self.Owner.WinState != WinState.Undefined || self.Owner.NonCombatant) return;
var hasAnything = self.World.ActorsWithTrait<MustBeDestroyed>()
.Any(a => a.Actor.Owner == self.Owner);
if (objectiveID < 0)
objectiveID = mo.Add(self.Owner, "Destroy all opposition!");
if (!hasAnything && !self.Owner.NonCombatant)
Lose(self);
if (!self.Owner.NonCombatant && self.Owner.HasNoRequiredUnits())
mo.MarkFailed(self.Owner, objectiveID);
var others = self.World.Players.Where(p => !p.NonCombatant
&& p != self.Owner && p.Stances[self.Owner] != Stance.Ally);
&& !p.IsAlliedWith(self.Owner));
if (!others.Any()) return;
if (others.All(p => p.WinState == WinState.Lost))
Win(self);
mo.MarkCompleted(self.Owner, objectiveID);
}
public void ResolveOrder(Actor self, Order order)
{
if (order.OrderString == "Surrender")
Lose(self);
mo.MarkFailed(self.Owner, objectiveID);
}
public void Lose(Actor self)
public void OnPlayerLost(Player player)
{
if (self.Owner.WinState == WinState.Lost) return;
self.Owner.WinState = WinState.Lost;
self.World.OnPlayerWinStateChanged(self.Owner);
Game.Debug("{0} is defeated.".F(player.PlayerName));
Game.Debug("{0} is defeated.".F(self.Owner.PlayerName));
foreach (var a in self.World.Actors.Where(a => a.Owner == self.Owner))
foreach (var a in player.World.Actors.Where(a => a.Owner == player))
a.Kill(a);
if (self.Owner == self.World.LocalPlayer)
if (player == player.World.LocalPlayer)
{
Game.RunAfterDelay(Info.NotificationDelay, () =>
Game.RunAfterDelay(info.NotificationDelay, () =>
{
if (Game.IsCurrentWorld(self.World))
Sound.PlayNotification(self.World.Map.Rules, self.Owner, "Speech", "Lose", self.Owner.Country.Race);
if (Game.IsCurrentWorld(player.World))
Sound.PlayNotification(player.World.Map.Rules, player, "Speech", "Lose", player.Country.Race);
});
}
}
public void Win(Actor self)
public void OnPlayerWon(Player player)
{
if (self.Owner.WinState == WinState.Won) return;
self.Owner.WinState = WinState.Won;
self.World.OnPlayerWinStateChanged(self.Owner);
Game.Debug("{0} is victorious.".F(player.PlayerName));
Game.Debug("{0} is victorious.".F(self.Owner.PlayerName));
if (self.Owner == self.World.LocalPlayer)
Game.RunAfterDelay(Info.NotificationDelay, () => Sound.PlayNotification(self.World.Map.Rules, self.Owner, "Speech", "Win", self.Owner.Country.Race));
if (player == player.World.LocalPlayer)
Game.RunAfterDelay(info.NotificationDelay, () => Sound.PlayNotification(player.World.Map.Rules, player, "Speech", "Win", player.Country.Race));
}
public void OnObjectiveAdded(Player player, int id) {}
public void OnObjectiveCompleted(Player player, int id) {}
public void OnObjectiveFailed(Player player, int id) {}
}
[Desc("Tag trait for things that must be destroyed for a short game to end.")]

1
OpenRA.Mods.RA/OpenRA.Mods.RA.csproj
View File

@@ -552,6 +552,7 @@
<Compile Include="GlobalUpgradable.cs" />
<Compile Include="Player\GlobalUpgradeManager.cs" />
<Compile Include="GainsStatUpgrades.cs" />
<Compile Include="Player\Extensions.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\OpenRA.Game\OpenRA.Game.csproj">

23
OpenRA.Mods.RA/Player/Extensions.cs Normal file
View File

@@ -0,0 +1,23 @@
#region Copyright & License Information
/*
* Copyright 2007-2014 The OpenRA Developers (see AUTHORS)
* This file is part of OpenRA, which is free software. It is made
* available to you under the terms of the GNU General Public License
* as published by the Free Software Foundation. For more information,
* see COPYING.
*/
#endregion
using System.Linq;
using OpenRA.Mods.RA;
namespace OpenRA
{
public static class Extensions
{
public static bool HasNoRequiredUnits(this Player player)
{
return player.World.ActorsWithTrait<MustBeDestroyed>().All(p => p.Actor.Owner != player);
}
}
}

2
OpenRA.Mods.RA/Scripting/LuaScriptInterface.cs
View File

@@ -319,7 +319,7 @@ namespace OpenRA.Mods.RA.Scripting
[LuaGlobal]
public bool RequiredUnitsAreDestroyed(Player player)
{
return world.ActorsWithTrait<MustBeDestroyed>().All(p => p.Actor.Owner != player);
return player.HasNoRequiredUnits();
}
[LuaGlobal]

90
OpenRA.Mods.RA/StrategicVictoryConditions.cs
View File

@@ -1,6 +1,6 @@
#region Copyright & License Information
/*
* Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
* Copyright 2007-2014 The OpenRA Developers (see AUTHORS)
* This file is part of OpenRA, which is free software. It is made
* available to you under the terms of the GNU General Public License
* as published by the Free Software Foundation. For more information,
@@ -17,41 +17,68 @@ namespace OpenRA.Mods.RA
public class StrategicPointInfo : TraitInfo<StrategicPoint> {}
public class StrategicPoint {}
public class StrategicVictoryConditionsInfo : ITraitInfo, Requires<ConquestVictoryConditionsInfo>
public class StrategicVictoryConditionsInfo : ITraitInfo, Requires<MissionObjectivesInfo>
{
[Desc("Amount of time (in game ticks) that the player has to hold all the strategic points.")]
public readonly int TicksToHold = 25 * 60 * 5; // ~5 minutes
[Desc("Should the timer reset when the player loses hold of a strategic point.")]
public readonly bool ResetOnHoldLost = true;
[Desc("Percentage of strategic points the player has to hold to win.")]
public readonly float RatioRequired = 0.5f; // 50% required of all koth locations
[Desc("Delay for the end game notification in milliseconds.")]
public int NotificationDelay = 1500;
public object Create(ActorInitializer init) { return new StrategicVictoryConditions(init.self, this); }
}
public class StrategicVictoryConditions : ITick, ISync
public class StrategicVictoryConditions : ITick, ISync, INotifyObjectivesUpdated
{
Actor self;
StrategicVictoryConditionsInfo info;
readonly StrategicVictoryConditionsInfo info;
[Sync] public int TicksLeft = 0;
[Sync] public int TicksLeft;
readonly Player player;
readonly MissionObjectives mo;
int objectiveID = -1;
public StrategicVictoryConditions(Actor self, StrategicVictoryConditionsInfo info)
public StrategicVictoryConditions(Actor self, StrategicVictoryConditionsInfo svcInfo)
{
this.self = self;
this.info = info;
info = svcInfo;
TicksLeft = info.TicksToHold;
player = self.Owner;
mo = self.Trait<MissionObjectives>();
}
public IEnumerable<TraitPair<StrategicPoint>> AllPoints
{
get { return self.World.ActorsWithTrait<StrategicPoint>(); }
get { return player.World.ActorsWithTrait<StrategicPoint>(); }
}
public int Total { get { return AllPoints.Count(); } }
int Owned { get { return AllPoints.Count( a => WorldUtils.AreMutualAllies( self.Owner, a.Actor.Owner )); } }
int Owned { get { return AllPoints.Count(a => WorldUtils.AreMutualAllies(player, a.Actor.Owner)); } }
public bool Holding { get { return Owned >= info.RatioRequired * Total; } }
public void Tick(Actor self)
{
if (self.Owner.WinState != WinState.Undefined || self.Owner.NonCombatant) return;
if (player.WinState != WinState.Undefined || player.NonCombatant) return;
if (objectiveID < 0)
objectiveID = mo.Add(player, "Hold all the strategic positions for a specified time!");
if (!self.Owner.NonCombatant && self.Owner.HasNoRequiredUnits())
mo.MarkFailed(self.Owner, objectiveID);
var others = self.World.Players.Where(p => !p.NonCombatant
&& !p.IsAlliedWith(self.Owner));
if (others.All(p => p.WinState == WinState.Lost))
mo.MarkCompleted(player, objectiveID);
if (others.Any(p => p.WinState == WinState.Won))
mo.MarkFailed(player, objectiveID);
// See if any of the conditions are met to increase the count
if (Total > 0)
@@ -59,10 +86,8 @@ namespace OpenRA.Mods.RA
if (Holding)
{
// Hah! We met ths critical owned condition
if (TicksLeft == 0)
TicksLeft = info.TicksToHold; // first tick -- this is crap.
else if (--TicksLeft == 0)
Won();
if (--TicksLeft == 0)
mo.MarkCompleted(player, objectiveID);
}
else if (TicksLeft != 0)
if (info.ResetOnHoldLost)
@@ -70,18 +95,33 @@ namespace OpenRA.Mods.RA
}
}
void Won()
public void OnPlayerLost(Player player)
{
// Player has won
foreach (var p in self.World.Players)
{
var cvc = p.PlayerActor.Trait<ConquestVictoryConditions>();
Game.Debug("{0} is defeated.".F(player.PlayerName));
if (p.WinState == WinState.Undefined && WorldUtils.AreMutualAllies(self.Owner, p))
cvc.Win(p.PlayerActor);
else if (p.WinState == WinState.Undefined)
cvc.Lose(p.PlayerActor);
foreach (var a in player.World.Actors.Where(a => a.Owner == player))
a.Kill(a);
if (player == player.World.LocalPlayer)
{
Game.RunAfterDelay(info.NotificationDelay, () =>
{
if (Game.IsCurrentWorld(player.World))
Sound.PlayNotification(player.World.Map.Rules, player, "Speech", "Lose", player.Country.Race);
});
}
}
public void OnPlayerWon(Player player)
{
Game.Debug("{0} is victorious.".F(player.PlayerName));
if (player == player.World.LocalPlayer)
Game.RunAfterDelay(info.NotificationDelay, () => Sound.PlayNotification(player.World.Map.Rules, player, "Speech", "Win", player.Country.Race));
}
public void OnObjectiveAdded(Player player, int id) {}
public void OnObjectiveCompleted(Player player, int id) {}
public void OnObjectiveFailed(Player player, int id) {}
}
}