public void ShouldRaiseIfMethodIsNullWhenAddMethod()
{
BaseBehavior baseBehavior = new BaseBehavior();
IBehavior behavior = baseBehavior.CreateDelegated();
behavior.Send("methodAt:put:", "aMethod", null);
}
public static bool IsHasUnitWithTear(
string unitName, int minTear, int maxTear, GameObject skillSender = null, GameObject skillObject = null)
{
BaseBehavior baseBehaviorComponent = skillSender.GetComponent <BaseBehavior>();
if (unitName != "")
{
foreach (GameObject unit in GameObject.FindGameObjectsWithTag("Building"))
{
BaseBehavior unitBehaviorComponent = unit.GetComponent <BaseBehavior>();
if (unitBehaviorComponent != null && unitBehaviorComponent.skillInfo.uniqueName == unitName && unitBehaviorComponent.ownerId == baseBehaviorComponent.ownerId)
{
if (unitBehaviorComponent.tear >= minTear && (unitBehaviorComponent.tear <= maxTear || maxTear == -1))
{
return(true);
}
}
}
}
else
{
if (baseBehaviorComponent.tear >= minTear && (baseBehaviorComponent.tear <= maxTear || maxTear == -1))
{
return(true);
}
}
return(false);
}
private void RemoveFirstBehavior()
{
BaseBehavior firstBehavior = behaviors.First.Value;
firstBehavior.EndBehavior(mob);
behaviors.RemoveFirst();
}
public void ShouldRaiseIfSelectorIsNullWhenAddMethod()
{
BaseBehavior baseBehavior = new BaseBehavior();
IBehavior behavior = baseBehavior.CreateDelegated();
behavior.Send("methodAt:put:", null, new MockMethod());
}
public void UpdatePointMarker()
{
UnityEngine.Profiling.Profiler.BeginSample("p UpdatePointMarker"); // Profiler
if (IsInCameraView())
{
if (unitSelectionComponent.isSelected && team == cameraController.team && ownerId == cameraController.userId)
{
if (target != null)
{
Color color = Color.green;
BaseBehavior targetBehaviorComponent = target.GetComponent <BaseBehavior>();
if (IsTeamEnemy(targetBehaviorComponent.team))
{
color = Color.red;
}
CreateOrUpdatePointMarker(color, target.transform.position, 0.0f, true, PointMarker.MarkerType.Arrow);
}
else
{
CreateOrUpdatePointMarker(Color.green, spawnTarget, 0.0f, true, PointMarker.MarkerType.Flag);
}
}
if (!unitSelectionComponent.isSelected)
{
DestroyPointMarker();
}
}
UnityEngine.Profiling.Profiler.EndSample(); // Profiler
}
public void DisplayObjectsInfo(List <GameObject> selectedObjects)
{
UnityEngine.Profiling.Profiler.BeginSample("p DisplayObjectsInfo"); // Profiler
if (selectedObjects.Count == 1)
{
unitBaseBehaviorComponent = selectedObjects[0].GetComponent <BaseBehavior>();
HtmlElement createdImage = DrawInfo(
"cblock", skillInfo: unitBaseBehaviorComponent.skillInfo, detailInfo: true, dinamicInfo: true,
tableStatistics: unitBaseBehaviorComponent.GetStatistics().ToArray(), drawHP: true);
createdImage.onclick = SelectObject;
}
else
{
displayedNames.Clear();
foreach (GameObject selectedObject in selectedObjects)
{
unitBaseBehaviorComponent = selectedObject.GetComponent <BaseBehavior>();
if (!displayedNames.Contains(unitBaseBehaviorComponent.skillInfo.uniqueName))
{
HtmlElement createdImage = DrawInfo(
"cblock", skillInfo: unitBaseBehaviorComponent.skillInfo, detailInfo: false,
tableStatistics: unitBaseBehaviorComponent.GetStatistics().ToArray());
displayedNames.Add(unitBaseBehaviorComponent.skillInfo.uniqueName);
createdImage.onclick = SelectOnly;
}
}
}
UnityEngine.Profiling.Profiler.EndSample(); // Profiler
}
public Brain(IBaseAdvancedRobot bot, IEnumerable <BaseBehavior> behaviours, IContext iContext)
{
_behaviours = behaviours;
_advancedRobot = bot;
_context = iContext;
SelectedBehavior = null;
}
public Champion(IStats playingStyle, int buyIn)
{
this.playingStyle = playingStyle;
this.BuyIn = buyIn;
this.preflopBehavior = new PreflopBehavior(playingStyle);
this.postflopBehavior = new PostflopBehavior(playingStyle);
}
public void ShouldRaiseIfSelectorIsNullWhenLookup()
{
BaseBehavior baseBehavior = new BaseBehavior();
IBehavior behavior = baseBehavior.CreateDelegated();
behavior.Send("lookup:", null);
}
public override bool[] UICommand(string commandName)
{
bool[] result = { false, false };
if (!unitSelectionComponent.isSelected)
{
return(result);
}
if (team != cameraController.team || CameraController.isHotkeysBlocked)
{
return(result);
}
bool[] skillResult = ActivateSkills(commandName);
if (skillResult[0] || skillResult[1])
{
return(skillResult);
}
if (state == BuildingState.Builded)
{
foreach (GameObject unit in producedUnits)
{
BaseBehavior baseBehaviorComponent = unit.GetComponent <BaseBehavior>();
if (baseBehaviorComponent.skillInfo.uniqueName == commandName || Input.GetKeyDown(baseBehaviorComponent.skillInfo.productionHotkey))
{
if (productionQuery.Count >= uqeryLimit)
{
return(result);
}
//Debug.Log(producedUnits.Count);
// if not enough resources -> return second element true
result[1] = !SpendResources(baseBehaviorComponent.skillInfo.costFood, baseBehaviorComponent.skillInfo.costGold, baseBehaviorComponent.skillInfo.costWood);
if (result[1])
{
return(result);
}
productionQuery.Add(unit);
ProductionQueryUpdated();
if (productionQuery.Count <= 1)
{
buildTimer = baseBehaviorComponent.skillInfo.timeToBuild;
}
result[0] = true;
return(result);
}
}
}
if (commandName == "stop" || Input.GetKeyDown(KeyCode.H))
{
StopAction(SendRPC: true);
result[0] = true;
return(result);
}
return(result);
}
public void ElementStopVisible(GameObject target)
{
BaseBehavior baseBehaviorComponent = target.GetComponent <BaseBehavior>();
BaseBehavior senderBaseBehavior = gameObject.GetComponentInParent <BaseBehavior>();
baseBehaviorComponent.StopVisible(senderBaseBehavior);
// Debug.Log("ElementStopVisible: " + target.name);
}
public override void Die()
{
Destroy(hpBar.gameObject);
BaseBehavior deathBehavior = ScriptableObject.CreateInstance <DieBehavior>();
deathBehavior.Init(BehaviorPriority.Vital, null, 0);
fsm.CheckAndAddBehavior(deathBehavior);
}
// Update is called once per frame
void Update()
{
if (IsDeath() || !isUpdating)
{
return;
}
hpBar.UpdateBar(curHP, maxHP, transform.position);
UpdateTarget("Alley", ref target);
if (target == null)
{
if (fsm.CurBehaviorType != Type.GetType("IdleBehavior"))
{
BaseBehavior idleBehavior = ScriptableObject.CreateInstance <IdleBehavior>();
idleBehavior.Init(BehaviorPriority.Basic, null, 0);
fsm.CheckAndAddBehavior(idleBehavior);
}
}
else
{
Vector3 subVec = target.transform.position - transform.position;
subVec.y = 0;
if (subVec.sqrMagnitude <= sqrAttRad)
{
if (fsm.CurBehaviorType != Type.GetType("AnimEventBehavior"))
{
transform.forward = subVec.normalized;
string animTrigger = "";
string soundKey = "";
if (UnityEngine.Random.Range(0, 2) == 0)
{
animTrigger = "att1";
soundKey = "EnemyAtt";
}
else
{
animTrigger = "att2";
soundKey = "EnemyAttDouble";
}
BaseBehavior attBehavior = ScriptableObject.CreateInstance <AnimEventBehavior>();
attBehavior.Init(BehaviorPriority.Att, new AnimEventBData(animTrigger, mainSoundPlayer, soundKey, 0.2f), 2.0f);
fsm.CheckAndAddBehavior(attBehavior);
}
}
else
{
runBehaviorData.dest = target.transform.position;
if (fsm.CurBehaviorType != Type.GetType("RunBehavior"))
{
BaseBehavior walkBehavior = ScriptableObject.CreateInstance <RunBehavior>();
walkBehavior.Init(BehaviorPriority.Basic, runBehaviorData, 0);
fsm.CheckAndAddBehavior(walkBehavior);
}
}
}
}
public static string SaveGame()
{
CameraController cameraController = Camera.main.GetComponent <CameraController>();
string saveName = DateTime.Now.ToString("MM_dd_yyyy_HH_mm_ss");
QuickSaveWriter quickSaveWriter = QuickSaveWriter.Create(saveName);
quickSaveWriter.Write(GameInfo.MAP_SEED, GameInfo.mapSeed);
quickSaveWriter.Write(GameInfo.MAP_SIZE, GameInfo.mapSize);
quickSaveWriter.Write("playerTeam", GameInfo.playerTeam);
quickSaveWriter.Write("cameraPosition", Camera.main.transform.position);
quickSaveWriter.Write("cameraRotation", Camera.main.transform.rotation);
quickSaveWriter.Write("gold", cameraController.resources[BaseBehavior.ResourceType.Gold]);
quickSaveWriter.Write("wood", cameraController.resources[BaseBehavior.ResourceType.Wood]);
quickSaveWriter.Write("food", cameraController.resources[BaseBehavior.ResourceType.Food]);
quickSaveWriter.Write("favor", cameraController.resources[BaseBehavior.ResourceType.Favor]);
int index = 0;
foreach (GameObject unitObject in GameObject.FindGameObjectsWithTag("Building").Concat(GameObject.FindGameObjectsWithTag("Unit")))
{
BaseBehavior unitBaseBehavior = unitObject.GetComponent <BaseBehavior>();
unitBaseBehavior.Save(ref quickSaveWriter, index);
index++;
}
quickSaveWriter.Write("indexCount", index);
TerrainGenerator terrainGenerator = Terrain.activeTerrain.GetComponent <TerrainGenerator>();
// Blind texture
Color[] colors = terrainGenerator.blindTexture2D.GetPixels();
int[] blindInfo = new int[colors.Length];
for (int i = 0; i < colors.Length; i++)
{
blindInfo[i] = colors[i] == Color.black ? 1 : 0;
}
quickSaveWriter.Write("blindTextureData", blindInfo);
// Binds
for (int number = 1; number <= 9; number++)
{
int[] binds = new int[cameraController.unitsBinds[KeyCode.Alpha0 + number].Count];
int i = 0;
foreach (GameObject bindObject in cameraController.unitsBinds[KeyCode.Alpha0 + number])
{
BaseBehavior bindObjectBaseBehavior = bindObject.GetComponent <BaseBehavior>();
binds[i] = bindObjectBaseBehavior.uniqueId;
i++;
}
quickSaveWriter.Write(new StringBuilder(15).AppendFormat("{0}_{1}", number, "bind").ToString(), binds);
}
quickSaveWriter.Commit();
return(saveName);
}
public void CheckAndAddBehavior(BaseBehavior behavior)
{
while (LastBehavior() && (LastBehavior().Priority <= behavior.Priority))
{
RemoveLastBehavior();
}
behaviors.AddLast(behavior);
}
public void AllocateObjectWithSizeUsingSend()
{
BaseBehavior behavior = new BaseBehavior();
IObject obj = (IObject)behavior.Send("allocate:", 10);
Assert.IsNotNull(obj);
Assert.AreEqual(10, obj.Size);
}
public void HasLookupMethod()
{
BaseBehavior behavior = new BaseBehavior();
IMethod lookupMethod = (IMethod)behavior.Send("lookup:", "lookup:");
Assert.IsNotNull(lookupMethod);
Assert.IsInstanceOfType(lookupMethod, typeof(BaseLookupMethod));
}
protected void Add(Type type, System.Object data, BehaviorPriority priority, float lifeTime)
{
this.priority = priority;
BaseBehavior newBehavior = ScriptableObject.CreateInstance(type) as BaseBehavior;
newBehavior.Init(priority, data, lifeTime);
behaviors.AddLast(newBehavior);
}
public void HasBehaviorMethod()
{
BaseBehavior behavior = new BaseBehavior();
IMethod behaviorMethod = (IMethod)behavior.Send("lookup:", "vtable");
Assert.IsNotNull(behaviorMethod);
Assert.IsInstanceOfType(behaviorMethod, typeof(BaseBehaviorMethod));
}
public void HasAllocateMethod()
{
BaseBehavior behavior = new BaseBehavior();
IMethod allocateMethod = (IMethod)behavior.Send("lookup:", "allocate:");
Assert.IsNotNull(allocateMethod);
Assert.IsInstanceOfType(allocateMethod, typeof(BaseAllocateMethod));
}
public void HasDelegateMethod()
{
BaseBehavior behavior = new BaseBehavior();
IMethod delegateMethod = (IMethod)behavior.Send("lookup:", "delegated");
Assert.IsNotNull(delegateMethod);
Assert.IsInstanceOfType(delegateMethod, typeof(BaseDelegateMethod));
}
public void ShouldRaiseIfSelectorIsUnknownWhenSend()
{
BaseObject obj = new BaseObject();
BaseBehavior behavior = new BaseBehavior();
obj.Behavior = behavior;
obj.Send("aMethod", null);
}
public void CreateBaseObjectAndSetBehavior()
{
BaseObject obj = new BaseObject();
BaseBehavior behavior = new BaseBehavior();
obj.Behavior = behavior;
Assert.AreEqual(behavior, obj.Behavior);
}
public void AllocateObjectWithSize()
{
BaseBehavior behavior = new BaseBehavior();
IObject obj = behavior.Allocate(10);
Assert.IsNotNull(obj);
Assert.AreEqual(10, obj.Size);
}
public void HasAddMethodMethod()
{
BaseBehavior behavior = new BaseBehavior();
IMethod addMethodMethod = (IMethod)behavior.Send("lookup:", "methodAt:put:");
Assert.IsNotNull(addMethodMethod);
Assert.IsInstanceOfType(addMethodMethod, typeof(BaseAddMethodMethod));
}
public void NullIfUnknownMethodInLookup()
{
BaseBehavior baseBehavior = new BaseBehavior();
IBehavior behavior = baseBehavior.CreateDelegated();
IMethod retrievedMethod = (IMethod)behavior.Send("lookup:", "unknownMethod");
Assert.IsNull(retrievedMethod);
}
public void DisplayDetailInfo(GameObject unit)
{
UnityEngine.Profiling.Profiler.BeginSample("p DisplayDetailInfo"); // Profiler
if (unit == null)
{
return;
}
unitBaseBehaviorComponent = unit.GetComponent <BaseBehavior>();
// Set health
foreach (var element in UI.document.getElementsByClassName("unitHealth"))
{
element.style.width = new StringBuilder(16).AppendFormat("{0:F0}%", unitBaseBehaviorComponent.health / unitBaseBehaviorComponent.maxHealth * 100).ToString();
}
foreach (var element in UI.document.getElementsByClassName("dinamicInfo"))
{
element.innerHTML = "";
BaseBehavior.ResourceType resourseDisplayType = BaseBehavior.ResourceType.None;
string gatgherInfo = "";
float resources = 0.0f;
if (unitBaseBehaviorComponent != null && unitBaseBehaviorComponent.resourceHold > 0)
{
resources = unitBaseBehaviorComponent.resourceHold;
resourseDisplayType = unitBaseBehaviorComponent.resourceType;
UnitBehavior.ResourceGatherInfo resourceGatherInfo = unit.GetComponent <UnitBehavior>().GetResourceFarmByType(unitBaseBehaviorComponent.interactType, resourseDisplayType);
gatgherInfo = new StringBuilder(30).AppendFormat(" ({0:F2} per second. Maximum: {1:F1})", resourceGatherInfo.gatherPerSecond, resourceGatherInfo.maximumCapacity).ToString();
}
else if (unitBaseBehaviorComponent.resourceCapacity > 0)
{
resources = unitBaseBehaviorComponent.resourceCapacity;
resourseDisplayType = unitBaseBehaviorComponent.resourceCapacityType;
}
if (resourseDisplayType != BaseBehavior.ResourceType.None)
{
Dom.Element statusticDiv = UI.document.createElement("p");
if (resourseDisplayType == BaseBehavior.ResourceType.Food)
{
statusticDiv.innerHTML = new StringBuilder(50).AppendFormat("Food: {0:F0} {1}", resources, gatgherInfo).ToString();
}
else if (resourseDisplayType == BaseBehavior.ResourceType.Gold)
{
statusticDiv.innerHTML = new StringBuilder(50).AppendFormat("Gold: {0:F0} {1}", resources, gatgherInfo).ToString();
}
else if (resourseDisplayType == BaseBehavior.ResourceType.Wood)
{
statusticDiv.innerHTML = new StringBuilder(50).AppendFormat("Wood: {0:F0} {1}", resources, gatgherInfo).ToString();
}
element.appendChild(statusticDiv);
}
}
UnityEngine.Profiling.Profiler.EndSample(); // Profiler
}
public void CreateBaseBehavior()
{
BaseBehavior behavior = new BaseBehavior();
Assert.IsNotNull(behavior);
Assert.IsNotNull(behavior.Behavior);
Assert.IsNull(behavior.Parent);
Assert.IsNotNull(behavior.Methods);
Assert.AreEqual(0, behavior.Size);
}
public void AddAndLookupMethod()
{
BaseBehavior behavior = new BaseBehavior();
MockMethod method = new MockMethod();
behavior.Send("methodAt:put:", "aMethod", method);
Assert.AreEqual(method, behavior.Lookup("aMethod"));
Assert.AreEqual(method, behavior.Send("lookup:", "aMethod"));
}
public void LookupMethods()
{
BaseBehavior behavior = new BaseBehavior();
Assert.IsNotNull(behavior.Lookup("lookup:"));
Assert.IsNotNull(behavior.Lookup("allocate:"));
Assert.IsNotNull(behavior.Lookup("delegated"));
Assert.IsNotNull(behavior.Lookup("methodAt:put:"));
Assert.IsNotNull(behavior.Lookup("vtable"));
}
public void AddBehavior(BaseBehavior behavior)
{
behaviors.Add (behavior);
}
public void addBehavior(BaseBehavior b) {
currentAI.Add(b);
currentAI.Sort(SortBehavior);
}
public void MyIntBaseBehaviorConsumer(int a, BaseBehavior b)
{
Debug.Log(string.Format("MyIntBaseBehaviorConsumer({0}, {1}) called", a, b));
}
public void removeBehavior(BaseBehavior b) {
currentAI.Remove(b);
}
int SortBehavior(BaseBehavior b1, BaseBehavior b2)
{
return b2.priority - b1.priority;
}
