LeaderHardWired()
{
m_db = Utils.Db.GetCurDwg();
using (CompBldrCurSpace compBldr = new CompBldrCurSpace(m_db)) {
compBldr.Start();
compBldr.PushXform(Utils.Db.GetUcsMatrix(m_db));
Point3d startPoint = new Point3d(0.0, 0.0, 0.0);
Point3d midPoint = new Point3d(50.0, 50.0, 0.0);
Point3d endPoint = new Point3d(100.0, 50.0, 0.0);
Point3dCollection pts = new Point3dCollection();
pts.Add(startPoint);
pts.Add(midPoint);
pts.Add(endPoint);
Leader leader = new Leader();
foreach (Point3d pt in pts)
{
leader.AppendVertex(pt);
}
compBldr.AddToDb(leader);
compBldr.Commit();
}
}
public void WriteTo(KafkaBinaryWriter writer)
{
Guard.NotNull(writer, "writer");
// if leader exists
writer.Write(PartitionId);
if (Leader != null)
{
writer.Write((byte)1);
Leader.WriteTo(writer);
}
else
{
writer.Write((byte)0);
}
// number of replicas
writer.Write((short)Replicas.Count());
foreach (var replica in Replicas)
{
replica.WriteTo(writer);
}
// number of in-sync replicas
writer.Write((short)Isr.Count());
foreach (var isr in Isr)
{
isr.WriteTo(writer);
}
writer.Write((byte)0);
}
public override string ToString()
{
var sb = new StringBuilder(4096);
sb.AppendFormat(
"PartitionMetadata.ParitionId:{0},Leader:{1},Replicas Count:{2},Isr Count:{3}",
PartitionId,
Leader == null ? "null" : Leader.ToString(),
Replicas.Count(),
Isr.Count());
var i = 0;
foreach (var r in Replicas)
{
sb.AppendFormat(",Replicas[{0}]:{1}", i, r);
i++;
}
i = 0;
foreach (var sr in Isr)
{
sb.AppendFormat(",Isr[{0}]:{1}", i, sr);
i++;
}
var s = sb.ToString();
sb.Length = 0;
return(s);
}
protected override bool Update()
{
try
{
Leader leader = (Leader)Entity;
if (_mIsJigStarted)
{
if (leader.NumVertices > 1)
{
leader.RemoveLastVertex();
}
}
Point3d lastVertex = leader.VertexAt(leader.NumVertices - 1);
if (!_mTempPoint.Equals(lastVertex))
{
leader.AppendVertex(_mTempPoint);
_mIsJigStarted = true;
}
}
catch (System.Exception ex)
{
BaseObjs.writeDebug(ex.Message + " LdrText_JigLeader0.cs: line: 199");
}
return(true);
}
private void Entities_AddItem(EntityCollection sender, EntityCollectionEventArgs e)
{
if (e.Item.Type == EntityType.Leader)
{
Leader leader = (Leader)e.Item;
if (leader.Annotation != null)
{
entities.Add(leader.Annotation);
}
}
else if (e.Item.Type == EntityType.Hatch)
{
Hatch hatch = (Hatch)e.Item;
foreach (HatchBoundaryPath path in hatch.BoundaryPaths)
{
foreach (EntityObject entity in path.Entities)
{
entities.Add(entity);
}
}
}
OnEntityAddedEvent(e.Item);
e.Item.Owner = this;
}
public async Task ShouldAppendCommandToLocalLog()
{
_peers = new List <IPeer>();
for (var i = 0; i < 4; i++)
{
var peer = new RemoteControledPeer();
peer.SetAppendEntriesResponse(new AppendEntriesResponse(1, true));
_peers.Add(peer);
}
var log = new InMemoryLog();
_currentState = new CurrentState(_id, 0, default(string), 0, 0, default(string));
var leader = new Leader(_currentState, _fsm, (s) => _peers, log, _node, _settings, _rules, _loggerFactory.Object);
await leader.Accept(new FakeCommand());
log.ExposedForTesting.Count.ShouldBe(1);
bool PeersReceiveCorrectAppendEntries(List <IPeer> peers)
{
var passed = 0;
peers.ForEach(p =>
{
var rc = (RemoteControledPeer)p;
if (rc.AppendEntriesResponsesWithLogEntries == 1)
{
passed++;
}
});
return(passed == peers.Count);
}
var result = WaitFor(1000).Until(() => PeersReceiveCorrectAppendEntries(_peers));
result.ShouldBeTrue();
bool FirstTest(List <PeerState> peerState)
{
var passed = 0;
peerState.ForEach(pS =>
{
if (pS.MatchIndex.IndexOfHighestKnownReplicatedLog == 1)
{
passed++;
}
if (pS.NextIndex.NextLogIndexToSendToPeer == 2)
{
passed++;
}
});
return(passed == peerState.Count * 2);
}
result = WaitFor(1000).Until(() => FirstTest(leader.PeerStates));
result.ShouldBeTrue();
}
void HandleLeaderInput(Leader leader)
{
if (Input.GetKeyDown(Leader.speedupKey) || playerGUI.CurrentKeyPressed == Leader.speedupKey)
{
leader.ActivateSpeedupAbility();
}
}
public void ShouldSendEmptyAppendEntriesRpcOnElection()
{
_peers = new List <IPeer>();
for (var i = 0; i < 4; i++)
{
_peers.Add(new FakePeer(true));
}
_currentState = new CurrentState(_id, 0, default(string), 0, 0, default(string));
var leader = new Leader(_currentState, _fsm, s => _peers, _log, _node, _settings, _rules, _loggerFactory.Object);
bool TestPeers(List <IPeer> peers)
{
var passed = 0;
peers.ForEach(x =>
{
var peer = (FakePeer)x;
if (peer.AppendEntriesResponses.Count >= 1)
{
passed++;
}
});
return(passed == peers.Count);
}
var result = WaitFor(1000).Until(() => TestPeers(_peers));
result.ShouldBeTrue();
}
public void SetLeader(Player player)
{
if (player == null || player == Leader)
{
return;
}
if (!AllMembers.Contains(player))
{
Leader.SendLocalizeString(ChatLogFilters.CHATLOGFILTERS_SAY, Localized_text.TEXT_BG_PLAYER_NOT_IN_BG);
return;
}
Leader.SendLocalizeString(ChatLogFilters.CHATLOGFILTERS_SAY, Localized_text.TEXT_BG_LEADER_DEMOTE);
Leader = player;
_membersRWLock.EnterWriteLock();
try
{
AllMembers.Remove(Leader);
AllMembers.Insert(0, Leader);
}
finally { _membersRWLock.ExitWriteLock(); }
player.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_SAY, Localized_text.TEXT_BG_LEADER_PROMOTE);
WarbandCompositionDirty = true;
}
private void WarbandMove(string name, byte groupIndex)
{
groupIndex -= 1;
if (groupIndex > 4)
{
Leader.SendLocalizeString(ChatLogFilters.CHATLOGFILTERS_SAY, Localized_text.TEXT_BG_INVALID_MOVE_INDEX);
return;
}
if (Groups[groupIndex].HasMaxMembers)
{
return;
}
for (int i = 0; i < MaxGroups; ++i)
{
foreach (Player plr in Groups[i].Members)
{
if (plr.Name.Equals(name))
{
if (groupIndex == i)
{
return;
}
Groups[i].RemoveMember(plr, true);
plr.SetGroup(Groups[groupIndex]);
WarbandCompositionDirty = true;
return;
}
}
}
}
public async Task <List <Leader> > GetLeaders()
{
var leaders = new List <Leader>();
// Get a list of the squads
var squadCollection = _mongoDatabase.GetCollection <BsonDocument>("squads");
using (var cursor = await squadCollection.FindAsync(new BsonDocument()))
{
while (await cursor.MoveNextAsync())
{
var batch = cursor.Current;
foreach (var document in batch)
{
var leader = new Leader();
BsonElement squadName;
BsonElement squadImage;
if (document.TryGetElement("squadName", out squadName))
{
leader.SquadName = squadName.Value.AsString;
}
;
if (document.TryGetElement("squadImage", out squadImage))
{
leader.SquadImage = squadImage.Value.AsString;
}
;
leader.AllTimeScore = 100;
leaders.Add(leader);
}
}
}
return(leaders);
}
private void TeleportToVictory(int winnerID)
{
PlayerData winner = playersSorted.Find(p => p.TokenSelected == winnerID);
playersSorted.Remove(winner);
playersSorted.Insert(0, winner);
int realPlayerPlace = playersSorted.FindIndex((obj) => obj.TokenSelected == GameData.Instance.realPlayerID);
level.OnEndOfFrame += delegate {
Player player = level.Tracker.GetEntity <Player>();
Leader.StoreStrawberries(player.Leader);
level.Remove(player);
level.UnloadLevel();
level.Session.Level = "Game_VictoryRoyale";
List <Vector2> spawns = new List <Vector2>(level.Session.LevelData.Spawns.ToArray());
// Sort the spawns so the highest one is first
spawns.Sort((x, y) => { return(x.Y.CompareTo(y.Y)); });
level.Session.RespawnPoint = level.GetSpawnPoint(new Vector2(spawns[realPlayerPlace].X, spawns[realPlayerPlace].Y));
level.LoadLevel(Player.IntroTypes.Jump);
level.Tracker.GetEntity <GameEndController>().winnerID = winnerID;
Leader.RestoreStrawberries(player.Leader);
};
}
public void ShouldBeAbleToHandleWhenLeaderHasNoLogsAndCandidatesReturnFail()
{
_peers = new List <IPeer>();
for (var i = 0; i < 4; i++)
{
_peers.Add(new FakePeer(true, true, true));
}
_currentState = new CurrentState(_id, 1, default(string), 0, 0, default(string));
var leader = new Leader(_currentState, _fsm, (s) => _peers, _log, _node, _settings, _rules, _loggerFactory.Object);
bool TestPeerStates(List <PeerState> peerState)
{
var passed = 0;
peerState.ForEach(pS =>
{
if (pS.MatchIndex.IndexOfHighestKnownReplicatedLog == 0)
{
passed++;
}
if (pS.NextIndex.NextLogIndexToSendToPeer == 1)
{
passed++;
}
});
return(passed == peerState.Count * 2);
}
var result = WaitFor(1000).Until(() => TestPeerStates(leader.PeerStates));
result.ShouldBeTrue();
}
public async Task <IActionResult> PutLeader(int id, Leader leader)
{
if (id != leader.LeaderId)
{
return(BadRequest());
}
_context.Entry(leader).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LeaderExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult Create([Bind(Include = "LeaderID,Specialisation,SecondJob,Sallary,PersonID")] Leader leader)
{
if (ModelState.IsValid)
{
db.Leaders.Add(leader);
if (UserManager.GetRoles(leader.LeaderID) != null)
{
if (UserManager.GetRoles(leader.LeaderID).Contains("Trainer"))
{
Trainer trainer = db.Trainers.Find(leader.LeaderID);
UserManager.RemoveFromRole(trainer.TrainerID, "Trainer");
db.Trainers.Remove(trainer);
var challenge = db.Challenges.Where(x => x.CurrentTrainerID == leader.LeaderID).ToList();
foreach (var ch in challenge)
{
db.Challenges.Remove(ch);
}
}
}
UserManager.AddToRole(leader.LeaderID, "Leader");
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.LeaderID = new SelectList(db.Users, "Id", "FirstName", leader.LeaderID);
return(View(leader));
}
private void SpawnAI()
{
while (_leaders.Count < settings.maxAmountOfPlayers)
{
PlayerConfiguration configuration = new PlayerConfiguration();
settings.players.Add(configuration);
var nickname = settings.RandomNicknameTable();
nickname.taken = true;
configuration.SetNickname(nickname.value);
var skin = settings.RandomSkinTable();
skin.taken = true;
configuration.SetSkin(skin.value);
Transform random = spawnSpots[Random.Range(0, spawnSpots.Count)];
spawnSpots.Remove(random);
GameObject go = Instantiate(settings.aiPrefab, random.position, random.rotation, transform);
Leader leader = go.GetComponent <Leader>();
leader.SetConfiguration(configuration);
_leaders.Add(leader);
}
}
static void Main(string[] args)
{
IFarmer farmer = new Farmer();
farmer.FeedAnimals();
ILeader leader = new Leader();
leader.Lead();
try
{
IGodInterface warriorGod = new WarriorGod();
// this will break
warriorGod.FeedAnimals();
warriorGod.Lead();
warriorGod.Swoosh();
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(e);
}
Console.Read();
}
public IEnumerable <Leader> GetAllLeaders()
{
var leaders = new List <Leader>();
using (var connection = new SqlConnection(ConnectionString))
{
var command = new SqlCommand("SELECT * FROM Leaders", connection);
command.Connection.Open();
var reader = command.ExecuteReader();
while (reader.Read())
{
Int32.TryParse(reader["Id"].ToString().Trim(), out int id);
var title = reader["Title"].ToString().Trim();
var name = reader["Name"].ToString().Trim();
var surname = reader["Surname"].ToString().Trim();
var leader = new Leader(id, title, name, surname);
leaders.Add(leader);
}
}
return(leaders);
}
public void addVertex()
{
Leader ml = Entity as Leader;
// For the first point...
if (_mPts.Count == 0)
{
// Add a leader line
//_mLeaderLineIndex = ml.AddLeaderLine(_mLeaderIndex);
// And a start vertex
ml.AppendVertex(_mTempPoint);
// Add a second vertex that will be set
// within the jig
ml.AppendVertex(new Point3d(0, 0, 0));
}
else
{
// For subsequent points,
// just add a vertex
ml.AppendVertex(_mTempPoint);
}
// Reset the attachment point, otherwise
// it seems to get forgotten
// ml.TextAttachmentType = TextAttachmentType.AttachmentMiddle;
// Add the latest point to our history
_mPts.Add(_mTempPoint);
}
public BB_JigSplineArrow(Point3d pnt3dFirst, double txtSize, string nameLayer, Color color)
: base(new Leader())
{
_mPts = new Point3dCollection();
_mPts.Add(pnt3dFirst);
Layer.manageLayers(nameLayer);
Leader leader = Entity as Leader;
leader.DimensionStyle = Dim.getDimStyleTableRecord("Annotative");
leader.SetDatabaseDefaults();
try
{
leader.AppendVertex(pnt3dFirst);
}
catch (System.Exception ex)
{
BaseObjs.writeDebug(ex.Message + " BB_JigSplineArrow.cs: line: 32");
}
leader.IsSplined = true;
leader.Annotative = AnnotativeStates.True;
leader.HasArrowHead = true;
leader.Dimasz = txtSize;
leader.Layer = nameLayer;
leader.Color = color;
_mIsJigStarted = false;
}
Stream(ArrayList data, Leader leader)
{
data.Add(new Snoop.Data.ClassSeparator(typeof(Leader)));
data.Add(new Snoop.Data.Xyz("Elbow", leader.Elbow));
data.Add(new Snoop.Data.Xyz("End", leader.End));
}
public void RemoveMember(Player player)
{
for (int i = 0; i < MaxGroups; ++i)
{
if (Groups[i].IsEmpty || !Groups[i].RemoveMember(player))
{
continue;
}
_membersRWLock.EnterWriteLock();
try { AllMembers.Remove(player); }
finally { _membersRWLock.ExitWriteLock(); }
if (AllMembers.Count == 0)
{
Groups[0].RemoveFromWorldGroups();
}
if (player == Leader && AllMembers.Count > 0)
{
SetLeader(AllMembers.First());
}
WarbandCompositionDirty = true;
return;
}
Leader.SendLocalizeString(ChatLogFilters.CHATLOGFILTERS_SAY, Localized_text.TEXT_BG_PLAYER_NOT_IN_BG);
}
public ActionResult Create([Bind(Include = "TrainerID,CatchedPokemonsAmount,DexCompleteAmount,Allowance,PersonID")] Trainer trainer)
{
if (ModelState.IsValid)
{
trainer.PersonID = trainer.TrainerID;
db.Trainers.Add(trainer);
if (UserManager.GetRoles(trainer.TrainerID) != null)
{
if (UserManager.GetRoles(trainer.TrainerID).Contains("Leader"))
{
Leader leader = db.Leaders.Find(trainer.TrainerID);
UserManager.RemoveFromRole(leader.LeaderID, "Leader");
db.Leaders.Remove(leader);
}
var challenge = db.Challenges.Where(x => x.CurrentLeaderID == trainer.TrainerID).ToList();
foreach (var ch in challenge)
{
db.Challenges.Remove(ch);
}
}
UserManager.AddToRole(trainer.TrainerID, "Trainer");
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.TrainerID = new SelectList(db.Users, "Id", "FirstName", trainer.TrainerID);
return(View(trainer));
}
protected override bool Update()
{
try
{
// Set the last vertex to the new value
Leader leader = Entity as Leader;
if (_mIsJigStarted)
{
leader.RemoveLastVertex();
}
Point3d lastVertex = leader.VertexAt(leader.NumVertices - 1);
if (!_mTempPoint.Equals(lastVertex))
{
leader.AppendVertex(_mTempPoint);
_mIsJigStarted = true;
}
}
catch (System.Exception ex)
{
BaseObjs.writeDebug(string.Format("{0} BB_JigSplineLeader.cs: line: 165", ex.Message));
}
return(true);
}
public void Leader_WithMaximumData_Parses()
{
// arrange
var data = new List <string>
{
" [*] Onol Flankgranite the Silt of Turquoise (b.188 d. 340, Reign Began: 329), Inherited from mother, Married (d. 212)",
" 3 Children (out-lived 1 of them) -- Ages at death: 130 129 (d. 224)",
" Worshipped Elana Viperwashed (45%)"
};
var leaderType = "master";
// act
var leader = new Leader(data, leaderType, GetTestCivilization());
// assert
Assert.AreEqual("Onol Flankgranite the Silt of Turquoise", leader.Name);
Assert.AreEqual(188, leader.Birth.Year);
Assert.AreEqual(340, leader.Death.Year);
Assert.AreEqual(329, leader.ReignBegan.Year);
Assert.AreEqual("Inherited", Leader.InheritanceTypes[leader.Inheritance]);
Assert.AreEqual(Leader.InheritanceSource.Mother, leader.InheritedFromSource);
Assert.IsTrue(leader.Married);
Assert.AreEqual(3, leader.ChildrenCount);
Assert.AreEqual(130, leader.Children.First().AgeAtParentDeath);
Assert.AreEqual(224, leader.Children.Last().Death.Year);
}
public void OnPlayerJoin(PlayerInput input)
{
PlayerConfiguration configuration = new PlayerConfiguration();
settings.players.Add(configuration);
Transform random = spawnSpots[Random.Range(0, spawnSpots.Count)];
spawnSpots.Remove(random);
GameObject go = Instantiate(settings.playerPrefab, random.position, random.rotation, transform);
SelectionHud hud = input.transform.parent.GetComponentInChildren <SelectionHud>();
PlayerMover mover = go.GetComponent <PlayerMover>();
mover.PlayerIndex = input.playerIndex;
_playerJoined.Add(hud, go);
hud.SetInfo(this, settings, configuration, input);
_onTimerTriggered += hud.OnTimerTrigger;
_onTimerValueChanged += hud.OnTimerValueChanged;
Leader leader = go.GetComponent <Leader>();
leader.SetConfiguration(configuration);
_leaders.Add(leader);
_inputs.Add(input);
TimerIsOn = false;
}
addLdr(Point3dCollection pnt3ds, ObjectId idLayer, double sizeArrow, double sizeGap, Color color,
ObjectId idMTxt, string nameStyle = "Annotative", bool spline = false)
{
ObjectId idLdr = ObjectId.Null;
Leader ldr = new Leader();
try
{
using (Transaction tr = BaseObjs.startTransactionDb())
{
BlockTable BT = Blocks.getBlockTable();
BlockTableRecord MS = (BlockTableRecord)tr.GetObject(BT[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
ObjectId idDimStyle = Dim.getDimStyleTableRecord("Annotative");
DimStyleTableRecord dstr = (DimStyleTableRecord)tr.GetObject(idDimStyle, OpenMode.ForRead);
ldr.SetDatabaseDefaults();
ldr.HasArrowHead = true;
ldr.DimensionStyle = idDimStyle;
ldr.SetDimstyleData(dstr);
ldr.LayerId = idLayer;
ldr.Dimasz = sizeArrow;
ldr.Dimgap = sizeGap;
ldr.IsSplined = spline;
ldr.Color = color;
ldr.Annotative = AnnotativeStates.True;
for (int i = 0; i < pnt3ds.Count; i++)
{
try
{
ldr.AppendVertex(pnt3ds[i]);
}
catch (System.Exception ex)
{
BaseObjs.writeDebug(ex.Message + " Ldr.cs: line: 60");
}
}
idLdr = MS.AppendEntity(ldr);
tr.AddNewlyCreatedDBObject(ldr, true);
if (!idMTxt.IsNull)
{
ldr.Annotative = AnnotativeStates.True;
ldr.Annotation = idMTxt;
ldr.Dimtad = 0;
ldr.EvaluateLeader();
}
tr.Commit();
}// end using
}
catch (System.Exception ex)
{
BaseObjs.writeDebug(ex.Message + " Ldr.cs: line: 79");
}
return(idLdr);
}
public async Task <ActionResult <Leader> > PostLeader(Leader leader)
{
_context.Leader.Add(leader);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetLeader", new { id = leader.LeaderId }, leader));
}
public string GetLeadersByGroup(int id)
{
try {
string sql = string.Format(@"SELECT g.Leader, u.FirstName, u.LastName FROM Groups g
LEFT OUTER JOIN Users u
ON g.Leader = u.UserId
WHERE g.Id = {0}
ORDER BY u.FirstName ASC", id);
List <Leader> xx = new List <Leader>();
using (SqlConnection connection = new SqlConnection(G.connectionString)) {
connection.Open();
using (SqlCommand command = new SqlCommand(sql, connection)) {
using (SqlDataReader reader = command.ExecuteReader()) {
while (reader.Read())
{
Leader x = new Leader()
{
id = G.ReadI(reader, 0),
firstName = G.ReadS(reader, 1),
lastName = G.ReadS(reader, 2),
};
xx.Add(x);
}
}
}
connection.Close();
}
return(JsonConvert.SerializeObject(xx, Formatting.None));
} catch (Exception e) { return(JsonConvert.SerializeObject(e.Message, Formatting.None)); }
}
public LeadState(Leader leader, LeaderFlags flags, float leadStopDistance, INode treeStart)
{
_leader = leader;
_flags = flags;
_leadStopDistance = leadStopDistance;
_treeStart = treeStart;
}
// START - Use this for initialization
void Start()
{
_animator = GetComponent<Animator>();
this.leaderController = this.GetComponent<Leader> ();
XAxis = "L_XAxis_" + player;
YAxis = "L_YAxis_" + player;
Shout = "A_" + player;
influence = this.GetComponent<CircleCollider2D> ();
}
public override RAIN.Action.Action.ActionResult Start(RAIN.Core.Agent agent, float deltaTime)
{
unitTarget = null;
leader = agent.Avatar.GetComponent<Leader>();
if(leader == null)
return RAIN.Action.Action.ActionResult.FAILURE;
Transform target = agent.actionContext.GetContextItem<Transform>("target");
if(target == null)
return RAIN.Action.Action.ActionResult.FAILURE;
unitTarget = target.gameObject.GetComponent<Unit>();
if(unitTarget == null || !unitTarget.IsAlive())
return RAIN.Action.Action.ActionResult.FAILURE;
return RAIN.Action.Action.ActionResult.SUCCESS;
}
private void AttackLeader(Leader opponentLeader)
{
gameObject.GetComponent<Rigidbody>().velocity += Vector3.up * 20f;
if (IsCriticalStrike())
{
//Play CRITICAL ATTACK ANIMATION
opponentLeader.RecieveDamage(GetDamageOutput() * 2);
}
else
{
//Play NORMAL ATTACK ANIMATION
opponentLeader.RecieveDamage(GetDamageOutput());
}
atkCooldown = 1f;
anim.Play("Attack", 1, 0);
skinnedMesh.SetBlendShapeWeight(1, 100);
skinnedMesh.SetBlendShapeWeight(2, 0);
//transform.LookAt(opponentLeader.transform.position);
}
public void Initialize()
{
maxDelayinSeconds = int.Parse(CloudConfigurationManager.GetSetting("syncmaxdelayinseconds"));
checkinSeconds = int.Parse(CloudConfigurationManager.GetSetting("synccheckinseconds"));
//get all the dbs and their connectionstrings
char[] separators = {';'};
dbCxnMap = new Dictionary<string,string>();
string []clients = CloudConfigurationManager.GetSetting("syncgroup").Split(separators);
foreach (string client in clients)
{
dbCxnMap[client] = ConfigurationManager.ConnectionStrings[client].ConnectionString;
}
//find the leaders and followers
leaders = new List<Leader>();
foreach (string client in clients)
{
Leader ld = new Leader();
ld.Name = client;
ld.Followers = new List<Follower>();
ld.LastUpdated = DateTime.MinValue;
foreach (string others in clients)
{
if (String.Compare(others, client) == 0) continue;
Follower fl = new Follower();
fl.Name = others;
ld.Followers.Add(fl);
}
leaders.Add(ld);
}
//the blob that contains the status info
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
CloudConfigurationManager.GetSetting("blobConnectionString"));
string blobContainer = CloudConfigurationManager.GetSetting("blobContainer");
//create blob container and set permission
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
container = blobClient.GetContainerReference(blobContainer);
container.CreateIfNotExists();
BlobContainerPermissions containerPermissions = new BlobContainerPermissions();
containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob;
container.SetPermissions(containerPermissions);
}
// Use this for initialization
void OnEnable()
{
playerLeader = GameObject.Find(Names.PLAYER_LEADER);
enemyLeader = GameObject.Find(Names.ENEMY_LEADER);
playerLeaderScript = playerLeader.GetComponent<PlayerLeader>();
enemyLeaderScript = enemyLeader.GetComponent<EnemyLeader>();
}
// Use this for initialization
void Start()
{
thisMinion = gameObject.GetComponent<Minion>();
pelotonObject = thisMinion.peloton.gameObject;
peloton = pelotonObject.GetComponent<Peloton>();
leader = gameObject.GetComponent<Minion>().peloton.GetLeader();
leaderScript = AIManager.staticManager.GetLeaderByName(leader.name);
animator = gameObject.GetComponent<Animator>();
}
Stream(ArrayList data, Leader leader)
{
data.Add(new Snoop.Data.ClassSeparator(typeof(Leader)));
data.Add(new Snoop.Data.Xyz("Elbow", leader.Elbow));
data.Add(new Snoop.Data.Xyz("End", leader.End));
}
/// <summary>
/// 指揮官リストに項目を挿入する
/// </summary>
/// <param name="leader">挿入対象の項目</param>
/// <param name="position">挿入先の項目</param>
public static void InsertItem(Leader leader, Leader position)
{
int index = Items.IndexOf(position) + 1;
Log.Info("[Leader] Insert leader: {0} ({1}: {2}) <{3}>", index, leader.Id, leader.Name,
Countries.Strings[(int) leader.Country]);
Items.Insert(index, leader);
}
public override void RegisterLeader(Leader leader)
{
this.leader = commander;
}
public bool Select(Leader selector)
{
if (!isSelectable || !IsAlive())
{
isSelected = false;
return false;
}
isSelected = true;
if (selector != (Leader)Commander.player)
return true;
CreateSelected();
SetOutlineColor(selectedColor);
return true;
}
public void CloneUnit(Unit oldClone)
{
isSelectable = oldClone.isSelectable;
isSelected = oldClone.isSelected;
id = oldClone.id;
enemyName = oldClone.enemyName;
leader = oldClone.leader;
uName = oldClone.uName;
teamColor = oldClone.teamColor;
label = oldClone.label;
status = oldClone.status;
movementType = oldClone.movementType;
kills = oldClone.kills;
lastDamager = oldClone.lastDamager;
health = oldClone.health;
weapon = oldClone.weapon;
_initialWeapon = oldClone._initialWeapon;
aBase = oldClone.aBase;
raycastIgnoreLayers = Commander.player.raycastIgnoreLayers;
weapon.Pickup(this);
leader.ReplaceUnit(id, this);
if (isSelected)
SetOutlineColor(selectedColor);
else
SetOutlineColor(outlineColor);
orderData = oldClone.orderData;
if (orderData != null)
orderData.SetUnit(this);
skipSpawn = true;
SetTeamColor();
Invoke("AllowSpawn", 5.0f);
}
public virtual void RecieveOrder(OrderData data)
{
if (!isSelectable || movable && (motor == null || !motor.enabled) || IsPlayer())
return;
Order order = data.GetOrder();
if (data.MoveTypeWasChanged())
{
movementType = data.GetMoveType();
}
Transform target = data.GetOrderTarget();
if ((order == Order.stop || target == null) && movable)
{
motor.StopNavigation(uName + " recieved a stop order from its OrderData.", false);
return;
}
if (target == transform || orderData != null && order == orderData.GetOrder() && target == orderData.GetOrderTarget())
return;
//Debug.Log (this+" has recieved "+order);
ResetTarget();
orderData = data;
lastOrderer = orderData.GetLeader();
Objective objective = target.GetComponent<Objective>();
if (objective != null)
{
currentObjective = objective;
if (order == Order.attack)
attackObjective = objective;
else if (order == Order.defend)
defendObjective = objective;
}
if (movable)
{
if (target.GetComponent<Unit>() == null)
{
target = motor.MakeMoveTarget(target);
}
else
{
target = motor.MakeMoveTarget(target.gameObject, uName + "'s Attack Target", true, false);
}
if (Vector3.Distance(target.position, transform.position) < UnitMotor.MOVE_CLOSE_ENOUGH_DISTANCE)
{
if (order != Order.defend)
{
orderData.SetTarget(null);
orderData.SetOrder(Order.stop, true);
orderData.UpdatedByUnit();
ResetTarget();
motor.OnTargetReached();
}
return;
}
orderData.SetMoveTarget(target, this);
MoveTo(target, movementType, uName + " is moving due to order recieved by " + lastOrderer, false);
}
// This is a quick-and-dirty way for players to see that the unit has recieved orders correctly.
if (lastOrderer == (Leader)Commander.player)
{
Debug.Log(this + " is moving to " + target);
MessageList.Instance.AddMessage(uName + ", acknowledging " + order.ToString() + " order.");
}
}
public virtual void RegisterLeader(Leader newLeader)
{
if (newLeader == null)
return;
leader = newLeader;
if (!leader.IsOwnedByPlayer())
Destroy(label);
Deselect();
ResetTarget();
lastOrderer = null;
aBase = leader.aBase;
teamColor = leader.teamColor;
leader.RegisterUnit(this);
renderer.material.color = teamColor;
SetOutlineColor(outlineColor);
float distanceFromLeader = Vector3.Distance(transform.position, leader.transform.position);
if (leader != (Leader)Commander.player && distanceFromLeader >= MOVE_TO_LEADER_DISTANCE)
{
OrderData supportLeader = new OrderData(leader, this);
supportLeader.SetOrder(Order.move, false);
supportLeader.SetMoveType(MoveType.DefendSelf);
supportLeader.SetTarget(leader.transform);
RecieveOrder(supportLeader);
}
else
{
leader.UnitRequestOrders(this);
}
if (IsOwnedByPlayer() && !IsLedByPlayer())
MessageList.Instance.AddMessage(uName + ", acknowledging " + leader.name + " as my new leader.");
}
/// <summary>
/// Initializes a new instance of the <see cref="OrderData"/> class.
/// The simplest way to initialize. Requires a Leader which gave the orders and a Unit to recieve them.
/// If nothing is changed, this will give the unit a "stop" command.
/// </summary>
/// <param name='leader'>
/// Who is giving the orders?
/// </param>
/// <param name='unit'>
/// Who is recieving the orders?
/// </param>
public OrderData(Leader leader, Unit unit)
{
this.leader = leader;
this.unit = unit;
SetOrder(Order.stop, false);
}
public virtual void IsSeen(Leader seer, bool seen)
{
if (seen && seer.IsAlive())
{
if (!visibleBy.Contains(seer))
{
visibleBy.Add(seer);
ChangeLayer(defaultLayer);
}
}
else
{
if (visibleBy.Contains(seer))
visibleBy.Remove(seer);
if (visibleBy.Count == 0)
ChangeLayer(unitLayer);
}
}
/// <summary>
/// 指揮官リストの項目を移動する
/// </summary>
/// <param name="src">移動元の項目</param>
/// <param name="dest">移動先の項目</param>
public static void MoveItem(Leader src, Leader dest)
{
int srcIndex = Items.IndexOf(src);
int destIndex = Items.IndexOf(dest);
Log.Info("[Leader] Move leader: {0} -> {1} ({2}: {3}) <{4}>", srcIndex, destIndex, src.Id, src.Name,
Countries.Strings[(int) src.Country]);
if (srcIndex > destIndex)
{
// 上へ移動する場合
Items.Insert(destIndex, src);
Items.RemoveAt(srcIndex + 1);
}
else
{
// 下へ移動する場合
Items.Insert(destIndex + 1, src);
Items.RemoveAt(srcIndex);
}
}
/// <summary>
/// 一括編集の個別処理
/// </summary>
/// <param name="leader">対象指揮官</param>
/// <param name="args">一括編集のパラメータ</param>
private static void BatchEditLeader(Leader leader, LeaderBatchEditArgs args)
{
// 理想階級
if (args.Items[(int) LeaderBatchItemId.IdealRank])
{
if (leader.IdealRank != args.IdealRank)
{
leader.IdealRank = args.IdealRank;
leader.SetDirty(LeaderItemId.IdealRank);
SetDirty(leader.Country);
}
}
// スキル
if (args.Items[(int) LeaderBatchItemId.Skill])
{
if (leader.Skill != args.Skill)
{
leader.Skill = args.Skill;
leader.SetDirty(LeaderItemId.Skill);
SetDirty(leader.Country);
}
}
// 最大スキル
if (args.Items[(int) LeaderBatchItemId.MaxSkill])
{
if (leader.MaxSkill != args.MaxSkill)
{
leader.MaxSkill = args.MaxSkill;
leader.SetDirty(LeaderItemId.MaxSkill);
SetDirty(leader.Country);
}
}
// 経験値
if (args.Items[(int) LeaderBatchItemId.Experience])
{
if (leader.Experience != args.Experience)
{
leader.Experience = args.Experience;
leader.SetDirty(LeaderItemId.Experience);
SetDirty(leader.Country);
}
}
// 忠誠度
if (args.Items[(int) LeaderBatchItemId.Loyalty])
{
if (leader.Loyalty != args.Loyalty)
{
leader.Loyalty = args.Loyalty;
leader.SetDirty(LeaderItemId.Loyalty);
SetDirty(leader.Country);
}
}
// 開始年
if (args.Items[(int) LeaderBatchItemId.StartYear])
{
if (leader.StartYear != args.StartYear)
{
leader.StartYear = args.StartYear;
leader.SetDirty(LeaderItemId.StartYear);
SetDirty(leader.Country);
}
}
// 終了年
if (args.Items[(int) LeaderBatchItemId.EndYear])
{
if (leader.EndYear != args.EndYear)
{
leader.EndYear = args.EndYear;
leader.SetDirty(LeaderItemId.EndYear);
SetDirty(leader.Country);
}
}
// 引退年
if (args.Items[(int) LeaderBatchItemId.RetirementYear])
{
if (leader.RetirementYear != args.RetirementYear)
{
leader.RetirementYear = args.RetirementYear;
leader.SetDirty(LeaderItemId.RetirementYear);
SetDirty(leader.Country);
}
}
// 少将任官年
if (args.Items[(int) LeaderBatchItemId.Rank3Year])
{
if (leader.RankYear[0] != args.RankYear[0])
{
leader.RankYear[0] = args.RankYear[0];
leader.SetDirty(LeaderItemId.Rank3Year);
SetDirty(leader.Country);
}
}
// 中将任官年
if (args.Items[(int) LeaderBatchItemId.Rank2Year])
{
if (leader.RankYear[1] != args.RankYear[1])
{
leader.RankYear[1] = args.RankYear[1];
leader.SetDirty(LeaderItemId.Rank2Year);
SetDirty(leader.Country);
}
}
// 大将任官年
if (args.Items[(int) LeaderBatchItemId.Rank1Year])
{
if (leader.RankYear[2] != args.RankYear[2])
{
leader.RankYear[2] = args.RankYear[2];
leader.SetDirty(LeaderItemId.Rank1Year);
SetDirty(leader.Country);
}
}
// 元帥任官年
if (args.Items[(int) LeaderBatchItemId.Rank0Year])
{
if (leader.RankYear[3] != args.RankYear[3])
{
leader.RankYear[3] = args.RankYear[3];
leader.SetDirty(LeaderItemId.Rank0Year);
SetDirty(leader.Country);
}
}
}
/// <summary>
/// 指揮官リストから項目を削除する
/// </summary>
/// <param name="leader">削除対象の項目</param>
public static void RemoveItem(Leader leader)
{
Log.Info("[Leader] Remove leader: ({0}: {1}) <{2}>", leader.Id, leader.Name,
Countries.Strings[(int) leader.Country]);
Items.Remove(leader);
// 使用済みIDリストから削除する
IdSet.Remove(leader.Id);
}
private Leader readLeader(string dataType, string dataText, string fileName, StreamReader reader)
{
if (dataText == "<{>") {
// Start of block
Leader leader = new Leader();
string line = reader.ReadLine().Trim ();
do {
string[] lineParts;
//Split category name from data
lineParts = line.Split(":".ToCharArray(), 2);
//Remove any extra whitespace from parts & set descriptive variables
string newDataType = gameManager.LanguageMgr.StringToDataType(lineParts[0].Trim ());
string newDataText = lineParts[1].Trim ();
if (newDataType == "Name") {
leader.Name = readTextLine (newDataType, newDataText, fileName);
} else if (newDataType == "Type") {
leader.LeaderType = gameManager.LanguageMgr.StringToLType(readTextLine (newDataType, newDataText, fileName));
} else if (newDataType == "ID") {
leader.Id = readTextLine (newDataType, newDataText, fileName);
}
line = reader.ReadLine().Trim ();
} while (line != "<}>");
// End of block
if (leader.Id == default(string)) {
leader.Id = leader.Name;
}
return leader;
} else {
throw new System.Exception(string.Format("Error reading file {0}:: got \"{1}\" should be <{>", fileName, dataText));
}
}
public void SetLeader(GameObject leader)
{
this.leader = leader;
leaderScript = leader.GetComponent<Leader>();
}
public override void IsSeen(Leader seer, bool seen)
{
}
void Start()
{
leaderScript = AIManager.staticManager.GetLeaderByName(leader.name);
victims = new List<Peloton>();
menaces = new List<Peloton>();
gameObject.layer = LayerMask.NameToLayer("Element");
state = Names.STATE_FOLLOW_LEADER;
pelotonSource = GetComponent<AudioSource>();
radio = GameObject.Find(Names.RADIO).GetComponent<Radio>();
//leader = GameObject.Find("Leader"); // CAMBIARLO
//gameObject.layer = LayerMask.NameToLayer("Peloton");
}
/// <summary>
/// 指揮官定義行を解釈する
/// </summary>
/// <param name="lexer">字句解析器</param>
/// <returns>指揮官データ</returns>
private static Leader ParseLine(CsvLexer lexer)
{
string[] tokens = lexer.GetTokens();
// 空行を読み飛ばす
if (tokens == null)
{
return null;
}
// トークン数が足りない行は読み飛ばす
if (tokens.Length != (Misc.EnableRetirementYearLeaders ? 19 : 18))
{
Log.Warning("[Leader] Invalid token count: {0} ({1} L{2})", tokens.Length, lexer.FileName, lexer.LineNo);
// 末尾のxがない/余分な項目がある場合は解析を続ける
if (tokens.Length < (Misc.EnableRetirementYearLeaders ? 18 : 17))
{
return null;
}
}
// 名前指定のない行は読み飛ばす
if (string.IsNullOrEmpty(tokens[0]))
{
return null;
}
Leader leader = new Leader();
int index = 0;
// 名前
leader.Name = tokens[index];
index++;
// ID
int id;
if (!int.TryParse(tokens[index], out id))
{
Log.Warning("[Leader] Invalid id: {0} [{1}] ({1} L{2})", tokens[index], leader.Name, lexer.FileName,
lexer.LineNo);
return null;
}
leader.Id = id;
index++;
// 国家
if (string.IsNullOrEmpty(tokens[index]) || !Countries.StringMap.ContainsKey(tokens[index].ToUpper()))
{
Log.Warning("[Leader] Invalid country: {0} [{1}: {2}] ({3} L{4})", tokens[index], leader.Id, leader.Name,
lexer.FileName, lexer.LineNo);
return null;
}
leader.Country = Countries.StringMap[tokens[index].ToUpper()];
index++;
// 任官年
for (int i = 0; i < 4; i++)
{
int rankYear;
if (int.TryParse(tokens[index], out rankYear))
{
leader.RankYear[i] = rankYear;
}
else
{
leader.RankYear[i] = 1990;
Log.Warning("[Leader] Invalid rank{0} year: {1} [{2}: {3}] ({4} L{5})", i, tokens[index], leader.Id,
leader.Name, lexer.FileName, lexer.LineNo);
}
index++;
}
// 理想階級
int idealRank;
if (int.TryParse(tokens[index], out idealRank) && 0 <= idealRank && idealRank <= 3)
{
leader.IdealRank = (LeaderRank) (4 - idealRank);
}
else
{
leader.IdealRank = LeaderRank.None;
Log.Warning("[Leader] Invalid ideal rank: {0} [{1}: {2}] ({3} L{4})", tokens[index], leader.Id,
leader.Name, lexer.FileName, lexer.LineNo);
}
index++;
// 最大スキル
int maxSkill;
if (int.TryParse(tokens[index], out maxSkill))
{
leader.MaxSkill = maxSkill;
}
else
{
leader.MaxSkill = 0;
Log.Warning("[Leader] Invalid max skill: {0} [{1}: {2}] ({3} L{4})", tokens[index], leader.Id,
leader.Name, lexer.FileName, lexer.LineNo);
}
index++;
// 指揮官特性
uint traits;
if (uint.TryParse(tokens[index], out traits))
{
leader.Traits = traits;
}
else
{
leader.Traits = LeaderTraits.None;
Log.Warning("[Leader] Invalid trait: {0} [{1}: {2}] ({3} L{4})", tokens[index], leader.Id,
leader.Name, lexer.FileName, lexer.LineNo);
}
index++;
// スキル
int skill;
if (int.TryParse(tokens[index], out skill))
{
leader.Skill = skill;
}
else
{
leader.Skill = 0;
Log.Warning("[Leader] Invalid skill: {0} [{1}: {2}] ({3} L{4})", tokens[index], leader.Id, leader.Name,
lexer.FileName, lexer.LineNo);
}
index++;
// 経験値
int experience;
if (int.TryParse(tokens[index], out experience))
{
leader.Experience = experience;
}
else
{
leader.Experience = 0;
Log.Warning("[Leader] Invalid experience: {0} [{1}: {2}] ({3} L{4})", tokens[index], leader.Id,
leader.Name, lexer.FileName, lexer.LineNo);
}
index++;
// 忠誠度
int loyalty;
if (int.TryParse(tokens[index], out loyalty))
{
leader.Loyalty = loyalty;
}
else
{
leader.Loyalty = 0;
Log.Warning("[Leader] Invalid loyalty: {0} [{1}: {2}] ({3} L{4})", tokens[index], leader.Id, leader.Name,
lexer.FileName, lexer.LineNo);
}
index++;
// 兵科
int branch;
if (int.TryParse(tokens[index], out branch))
{
leader.Branch = (Branch) (branch + 1);
}
else
{
leader.Branch = Branch.None;
Log.Warning("[Leader] Invalid branch: {0} [{1}: {2}] ({3} L{4})", tokens[index], leader.Id, leader.Name,
lexer.FileName, lexer.LineNo);
}
index++;
// 画像ファイル名
leader.PictureName = tokens[index];
index++;
// 開始年
int startYear;
if (int.TryParse(tokens[index], out startYear))
{
leader.StartYear = startYear;
}
else
{
leader.StartYear = 1930;
Log.Warning("[Leader] Invalid start year: {0} [{1}: {2}] ({3} L{4})", tokens[index], leader.Id,
leader.Name, lexer.FileName, lexer.LineNo);
}
index++;
// 終了年
int endYear;
if (int.TryParse(tokens[index], out endYear))
{
leader.EndYear = endYear;
}
else
{
leader.EndYear = 1970;
Log.Warning("[Leader] Invalid end year: {0} [{1}: {2}] ({3} L{4})", tokens[index], leader.Id,
leader.Name, lexer.FileName, lexer.LineNo);
}
index++;
// 引退年
if (Misc.EnableRetirementYearLeaders)
{
int retirementYear;
if (int.TryParse(tokens[index], out retirementYear))
{
leader.RetirementYear = retirementYear;
}
else
{
leader.RetirementYear = 1999;
Log.Warning("[Leader] Invalid retirement year: {0} [{1}: {2}] ({3} L{4})", tokens[index], leader.Id,
leader.Name, lexer.FileName, lexer.LineNo);
}
}
else
{
leader.RetirementYear = 1999;
}
return leader;
}
public void startAnimation()
{
this.leaderController = this.GetComponent<Leader> ();
selectanimations ();
_animator.Play (Animator.StringToHash(_idleani));
}
/// <summary>
/// 指揮官リストに項目を追加する
/// </summary>
/// <param name="leader">挿入対象の項目</param>
public static void AddItem(Leader leader)
{
Log.Info("[Leader] Add leader: ({0}: {1}) <{2}>", leader.Id, leader.Name,
Countries.Strings[(int) leader.Country]);
Items.Add(leader);
}
/// <summary>
/// 一括編集
/// </summary>
/// <param name="args">一括編集のパラメータ</param>
public static void BatchEdit(LeaderBatchEditArgs args)
{
LogBatchEdit(args);
IEnumerable<Leader> leaders = GetBatchEditLeaders(args);
Country newCountry;
switch (args.ActionMode)
{
case BatchActionMode.Modify:
// 指揮官を一括編集する
foreach (Leader leader in leaders)
{
BatchEditLeader(leader, args);
}
break;
case BatchActionMode.Copy:
// 指揮官をコピーする
newCountry = args.Destination;
int id = args.Id;
foreach (Leader leader in leaders)
{
id = GetNewId(id);
Leader newLeader = new Leader(leader)
{
Country = newCountry,
Id = id
};
newLeader.SetDirtyAll();
Items.Add(newLeader);
}
// コピー先の国の編集済みフラグを設定する
SetDirty(newCountry);
// コピー先の国がファイル一覧に存在しなければ追加する
if (!FileNameMap.ContainsKey(newCountry))
{
FileNameMap.Add(newCountry, Game.GetLeaderFileName(newCountry));
SetDirtyList();
}
break;
case BatchActionMode.Move:
// 指揮官を移動する
newCountry = args.Destination;
foreach (Leader leader in leaders)
{
// 移動前の国の編集済みフラグを設定する
SetDirty(leader.Country);
leader.Country = newCountry;
leader.SetDirty(LeaderItemId.Country);
}
// 移動先の国の編集済みフラグを設定する
SetDirty(newCountry);
// 移動先の国がファイル一覧に存在しなければ追加する
if (!FileNameMap.ContainsKey(newCountry))
{
FileNameMap.Add(newCountry, Game.GetLeaderFileName(newCountry));
SetDirtyList();
}
break;
}
}
public override void RegisterLeader(Leader leader)
{
this.leader = this;
}
public override void IsSeen(Leader seer, bool seen)
{
if (seer.IsPlayer())
{
ToggleOutlines(seen);
}
}
