Example #1
0
        private void StateChange(SimulationEvent e)
        {
            // If the parent dies, kill the docked children

            //objectProxies = bbClient.GetObjectProxies(); // update my objects record

            string objectID = ((StringValue)e["ObjectID"]).value;
            string state    = ((StringValue)e["NewState"]).value;

            List <string> ids;

            if (state == "Dead" && objectProxies.ContainsKey(objectID))
            {
                ids = ((StringListValue)objectProxies[objectID]["DockedObjects"].GetDataValue()).strings;
                foreach (string id in ids)
                {
                    distClient.PutEvent(SimUtility.BuildStateChangeEvent(ref simModel, time, id, "Dead"));
                }
                ids = ((StringListValue)objectProxies[objectID]["DockedWeapons"].GetDataValue()).strings;
                foreach (string id in ids)
                {
                    distClient.PutEvent(SimUtility.BuildStateChangeEvent(ref simModel, time, id, "Dead"));
                }
            }
        }
        private void NewObject(SimulationEvent e)
        {
            string objectType = ((StringValue)e["ObjectType"]).value;

            Console.WriteLine(String.Format("Blackboard gets new object; ID: {0}; Type: {1}", ((StringValue)e["ID"]).value, objectType));
            SimulationObject ob = SimulationObjectFactory.BuildObject(ref simModel, objectType);

            ob.attributes["ID"] = e["ID"];



            // REFACTOR: I shouldn't actually do this.  I should only initialize the values that I own.
            //AD: I'm populating the values passed in the NewObject event into the SimulationObject
            foreach (string attname in ((AttributeCollectionValue)e["Attributes"]).attributes.Keys)
            {
                ob.attributes[attname] = ((AttributeCollectionValue)e["Attributes"])[attname];
            }
            blackboard.AddObject(ob);

            // Initialize StateDB objects

            if (((StringValue)e["ObjectType"]).value == "Team")
            {
                StateDB.Team t = new StateDB.Team(((StringValue)e["ID"]).value,
                                                  ((StringListValue)((AttributeCollectionValue)e["Attributes"]).attributes["TeamHostility"]).strings);

                StateDB.teams[t.id] = t;
            }
            else if (((StringValue)e["ObjectType"]).value == "DecisionMaker")
            {
                string teamID           = ((StringValue)((AttributeCollectionValue)e["Attributes"]).attributes["TeamMember"]).value;
                StateDB.DecisionMaker d = new StateDB.DecisionMaker(((StringValue)e["ID"]).value,
                                                                    StateDB.teams.ContainsKey(teamID) ? StateDB.teams[teamID] : null);

                StateDB.decisionMakers[d.id] = d;
            }
            else if (SimUtility.isPhysicalObject(objectType))
            {
                String linkedRegion = "";
                if (e.parameters.ContainsKey("LinkedRegion"))
                {
                    linkedRegion = ((StringValue)e["LinkedRegion"]).value;
                }

                StateDB.AddPhysicalObject(((StringValue)e["ID"]).value, objectType, linkedRegion);
            }
        }
Example #3
0
        private void TransferObject(SimulationEvent e)
        {
            string objectID            = ((StringValue)e["ObjectID"]).value;
            SimulationObjectProxy prox = objectProxies[objectID];

            string userID = ((StringValue)e["UserID"]).value;

            string donerUserID = ((StringValue)e["DonorUserID"]).value;

            prox["OwnerID"].SetDataValue(DataValueFactory.BuildString(userID));

            StateDB.physicalObjects[objectID].ownerID = userID;

            distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
                                                                   time,
                                                                   userID,
                                                                   String.Format("Ownership of {0} has been transferred from {1} to {2}", objectID, donerUserID, userID)));
            distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
                                                                   time,
                                                                   donerUserID,
                                                                   String.Format("Ownership of {0} has been transferred from {1} to {2}", objectID, donerUserID, userID)));
        }
Example #4
0
        private void TimeTick(SimulationEvent e)
        {
            int       oldTime = time;
            DataValue dv      = null;

            dv   = e["Time"];
            time = ((IntegerValue)dv).value;

            if (time % 1000 != 0)
            {
                return;
            }



            foreach (string s in ScoringDB.scores.Keys)
            {
                if (lastScore.ContainsKey(s))
                {
                    if (ScoringDB.scores[s].scoreValue != lastScore[s])
                    {
                        lastScore[s] = ScoringDB.scores[s].scoreValue;
                        foreach (string dm in ScoringDB.scores[s].displayDMs)
                        {
                            distClient.PutEvent(SimUtility.BuildScoreUpdateEvent(ref simModel, time, dm, s, ScoringDB.scores[s].scoreValue));
                        }
                    }
                }
                else
                {
                    lastScore[s] = ScoringDB.scores[s].scoreValue;
                    foreach (string dm in ScoringDB.scores[s].displayDMs)
                    {
                        distClient.PutEvent(SimUtility.BuildScoreUpdateEvent(ref simModel, time, dm, s, ScoringDB.scores[s].scoreValue));
                    }
                }
            }
        }
Example #5
0
        private void TimeTick(SimulationEvent e)
        {
            time = ((IntegerValue)e["Time"]).value;

            DataValue dv = null;

            SimulationObjectProxy targetProx = null;
            Vec3D targetLoc = new Vec3D(0, 0, 0);
            SimulationObjectProxy obProx = null;

            bool   selfDefenseStartAttack;
            string selfDefenseCapability;
            string selfDefenseTargetID;
            Dictionary <string, Dictionary <string, List <AttackCollectionValue.AttackValue> > > currentAttackCollection = new Dictionary <string, Dictionary <string, List <AttackCollectionValue.AttackValue> > >();
            //[ [TargetID]/[ CapabilityUsed]/[List of Attacks] ]
            Dictionary <string, List <AttackCollectionValue.AttackValue> > attacksToRemove = new Dictionary <string, List <AttackCollectionValue.AttackValue> >();

            // [AttackerID]/[List of attacks to remove]
            //as you clean up attacks, add them to this list.  once done iterating over targets, go through this list and update the attacks in the keys.
            foreach (string id in objectProxies.Keys)
            {
                obProx = objectProxies[id];
                //Generate Attack dictionary
                AttackCollectionValue attacks = (AttackCollectionValue)obProx["CurrentAttacks"].GetDataValue();

                foreach (AttackCollectionValue.AttackValue av in attacks.GetCurrentAttacks())
                {
                    if (!currentAttackCollection.ContainsKey(av.targetObjectId))
                    {
                        currentAttackCollection.Add(av.targetObjectId, new Dictionary <string, List <AttackCollectionValue.AttackValue> >());
                    }
                    if (!currentAttackCollection[av.targetObjectId].ContainsKey(av.capabilityName))
                    {
                        currentAttackCollection[av.targetObjectId].Add(av.capabilityName, new List <AttackCollectionValue.AttackValue>());
                    }
                    currentAttackCollection[av.targetObjectId][av.capabilityName].Add(av); //store pointer
                }

                selfDefenseStartAttack = ((BooleanValue)obProx["SelfDefenseStartAttack"].GetDataValue()).value;

                if (selfDefenseStartAttack)
                {
                    selfDefenseCapability = ((StringValue)obProx["SelfDefenseCapability"].GetDataValue()).value;
                    selfDefenseTargetID   = ((StringValue)obProx["SelfDefenseTargetID"].GetDataValue()).value;

                    targetProx = objectProxies[selfDefenseTargetID];

                    if (((AttackCollectionValue)obProx["CurrentAttacks"].GetDataValue()).GetCurrentAttacks().Count == 0 &&
                        ((StringValue)obProx["State"].GetDataValue()).value != "Dead" &&
                        ((StringValue)targetProx["State"].GetDataValue()).value != "Dead")
                    {
                        AttackObject(id, selfDefenseTargetID, selfDefenseCapability, 100, true);
                        if (((StringValue)obProx["AttackState"].GetDataValue()).value == "")
                        {
                            SendSelfDefenseAttackStarted(id, selfDefenseTargetID);
                        }
                    }
                }
            }

            foreach (string targetID in objectProxies.Keys)
            {
                targetProx = objectProxies[targetID];
                string currentState = ((StringValue)objectProxies[targetID]["State"].GetDataValue()).value;
                dv = targetProx["AttackState"].GetDataValue();
                if (((StringValue)dv).value == "BEING_ATTACKED")
                {
                    if (!currentAttackCollection.ContainsKey(targetID))
                    {
                        currentAttackCollection.Add(targetID, new Dictionary <string, List <AttackCollectionValue.AttackValue> >());
                        //this should not happen, or we're in trouble
                    }
                    int capabilitiesCompleted = 0; //this gets incremented as you add to attacksToRemove
                    foreach (String capability in currentAttackCollection[targetID].Keys)
                    {
                        //update attack windows for each attack object?
                        int attackEndTime = -1;
                        foreach (AttackCollectionValue.AttackValue av in currentAttackCollection[targetID][capability])
                        {
                            if (attackEndTime == -1)
                            {
                                attackEndTime = av.attackStartTime + av.attackTimeWindow;
                            }
                            else
                            {
                                attackEndTime = Math.Min(attackEndTime, av.attackStartTime + av.attackTimeWindow);
                            }
                        }
                        int newDuration = attackEndTime - time;
                        foreach (AttackCollectionValue.AttackValue av in currentAttackCollection[targetID][capability])
                        {
                            av.attackTimeWindow = attackEndTime - av.attackStartTime;// newDuration;
                        }

                        //check attack window vs current time
                        if (time >= attackEndTime)
                        {
                            //cleanup if needed

                            //add attacks to remove list

                            foreach (AttackCollectionValue.AttackValue av in currentAttackCollection[targetID][capability])
                            {
                                if (!attacksToRemove.ContainsKey(av.attackingObjectId))
                                {
                                    attacksToRemove.Add(av.attackingObjectId, new List <AttackCollectionValue.AttackValue>());
                                }
                                attacksToRemove[av.attackingObjectId].Add(av);
                            }

                            //check vulnerabilities
                            VulnerabilityValue targetVul = (VulnerabilityValue)targetProx["Vulnerability"].GetDataValue();
                            bool          attackSuccess  = false;
                            List <string> capabilitiesApplied;
                            List <string> attackers = new List <string>();

                            foreach (VulnerabilityValue.Transition t in targetVul.transitions)
                            {
                                foreach (String cap in t.GetAppliedCapabilities())
                                {
                                    if (!currentAttackCollection[targetID].ContainsKey(cap))
                                    {
                                        continue; //workaround for issue at USF; for some reason capability was not added to current attack collection.
                                    }
                                    foreach (AttackCollectionValue.AttackValue val in currentAttackCollection[targetID][cap])
                                    {
                                        string attackerID = val.attackingObjectId;
                                        if (!attackers.Contains(attackerID))
                                        {
                                            attackers.Add(attackerID);
                                        }
                                    }
                                }
                                if (t.ConditionsMet())
                                {
                                    capabilitiesApplied = t.GetAppliedCapabilities();
                                    // Send state change
                                    string          newState = t.state;
                                    SimulationEvent sc       = SimulationEventFactory.BuildEvent(ref simModel, "StateChange");
                                    ((StringValue)sc["ObjectID"]).value = targetID;
                                    ((StringValue)sc["NewState"]).value = newState;
                                    ((IntegerValue)sc["Time"]).value    = time;
                                    distClient.PutEvent(sc);
                                    foreach (string attackerID in attackers)
                                    {
                                        distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
                                                                                               time,
                                                                                               ((StringValue)(objectProxies[attackerID]["OwnerID"].GetDataValue())).value,
                                                                                               attackerID + " has succesfully engaged " + targetID));
                                        distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
                                                                                               time,
                                                                                               ((StringValue)(targetProx["OwnerID"].GetDataValue())).value,
                                                                                               targetID + " has been succesfully engaged by " + attackerID));

                                        ScoringDB.UpdateScore_StateChange(new ScoringDB.ActorFrame(attackerID,
                                                                                                   StateDB.physicalObjects[attackerID].speciesName,
                                                                                                   StateDB.physicalObjects[attackerID].ownerID,
                                                                                                   StateDB.physicalObjects[attackerID].activeRegions),
                                                                          currentState,
                                                                          t.state,
                                                                          new ScoringDB.ActorFrame(targetID,
                                                                                                   StateDB.physicalObjects[targetID].speciesName,
                                                                                                   StateDB.physicalObjects[targetID].ownerID,
                                                                                                   StateDB.physicalObjects[targetID].activeRegions));
                                    }


                                    t.ClearAppliedEffects();

                                    distClient.PutEvent(SimUtility.BuildHistory_AttackedObjectReportEvent(ref simModel,
                                                                                                          time,
                                                                                                          targetID,
                                                                                                          targetLoc,
                                                                                                          true,
                                                                                                          t.state));
                                    distClient.PutEvent(SimUtility.BuildAttackSucceededEvent(ref simModel, time, attackers[0], targetID, newState, capabilitiesApplied));
                                    attackSuccess = true;
                                    break;
                                }
                            }
                            //send messages
                            if (!attackSuccess)
                            {
                                foreach (String attackerID in attackers)
                                {
                                    distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
                                                                                           time,
                                                                                           ((StringValue)(objectProxies[attackerID]["OwnerID"].GetDataValue())).value,
                                                                                           attackerID + " has failed in engagement of " + targetID));
                                    distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
                                                                                           time,
                                                                                           ((StringValue)(targetProx["OwnerID"].GetDataValue())).value,
                                                                                           targetID + " has been unsuccesfully engaged by " + attackerID));
                                }
                                foreach (VulnerabilityValue.Transition t in targetVul.transitions)
                                {
                                    t.ClearAppliedEffects();
                                }

                                distClient.PutEvent(SimUtility.BuildHistory_AttackedObjectReportEvent(ref simModel,
                                                                                                      time,
                                                                                                      targetID,
                                                                                                      targetLoc,
                                                                                                      false,
                                                                                                      ""));
                            }

                            capabilitiesCompleted++;
                            //if there are more capabilities being applied than this one, don't remove target's attack state.
                            if (currentAttackCollection[targetID].Count - capabilitiesCompleted == 0)
                            {// this occurs when all attacks will be removed in this loop
                                dv = targetProx["AttackState"].GetDataValue();
                                ((StringValue)dv).value = "";
                                targetProx["AttackState"].SetDataValue(dv);
                            }
                        }
                    }

                    foreach (string attackerID in attacksToRemove.Keys)
                    {
                        SimulationObjectProxy attackerProxy = objectProxies[attackerID];
                        if (attackerProxy != null)
                        {
                            AttackCollectionValue acv = attackerProxy["CurrentAttacks"].GetDataValue() as AttackCollectionValue;
                            foreach (AttackCollectionValue.AttackValue attackVal in attacksToRemove[attackerID])
                            {
                                if (!acv.RemoveAttack(attackVal))
                                {
                                    acv.RemoveAttack(attackVal.capabilityName, attackVal.targetObjectId, attackVal.attackingObjectId, attackVal.attackStartTime);
                                }
                            }

                            attackerProxy["CurrentAttacks"].SetDataValue(acv);
                            if (((BooleanValue)attackerProxy["IsWeapon"].GetDataValue()).value)
                            {
                                distClient.PutEvent(SimUtility.BuildStateChangeEvent(ref simModel, time, attackerID, "Dead"));
                            }
                        }
                    }

                    if (capabilitiesCompleted > 0)
                    {//some attacks were removed, actually remove them from the currentAttackCollection, update attacker list.
                     //update attack lists (this will require some iteration over the attacks.
                        List <string> attackers = null;
                        dv        = targetProx["AttackerList"].GetDataValue();
                        attackers = ((StringListValue)dv).strings;
                        attackers.Clear();

                        foreach (String capability in currentAttackCollection[targetID].Keys)
                        {
                            foreach (AttackCollectionValue.AttackValue av in currentAttackCollection[targetID][capability])
                            {
                                if (!attackers.Contains(av.attackingObjectId))
                                {
                                    attackers.Add(av.attackingObjectId);
                                }
                            }
                        }

                        ((StringListValue)dv).strings = attackers;
                        targetProx["AttackerList"].SetDataValue(dv);
                    }
                }
            }
        }
Example #6
0
        private void AttackObject(string attackerID, string targetID, string capabilityName, int percentageApplied, bool isSelfDefense)
        {
            DataValue dv = null;


            //AD Note: on 9/23/09, we decided that Vulnerabilities would now have an "EngagementDuration", which is the Vulnerability
            // version of Capability's "AttackDuration".  If an EngagementDuration exists, it will override a Capability's AttackDuration.

            SimulationObjectProxy attackerProx = objectProxies[attackerID];
            SimulationObjectProxy targetProx   = objectProxies[targetID];

            CapabilityValue    attackerCap = (CapabilityValue)attackerProx["Capability"].GetDataValue();
            VulnerabilityValue targetVul   = (VulnerabilityValue)targetProx["Vulnerability"].GetDataValue();

            // Check to see if this attack can start

            if (((StringValue)attackerProx["AttackState"].GetDataValue()).value == "BEING_ATTACKED")
            {
                distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
                                                                       time,
                                                                       ((StringValue)(attackerProx["OwnerID"].GetDataValue())).value,
                                                                       attackerID + " is being engaged -- it can't initiate an engagement."));

                return;
            }
            if (targetVul.transitions.Count == 0)
            {
                distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
                                                                       time,
                                                                       ((StringValue)(attackerProx["OwnerID"].GetDataValue())).value,
                                                                       attackerID + " can't engage " + targetID + " -- object has no vulnerabilities."));
                return;
            }

            //AD 11/16/2009: New Attack Logic: Allow for partial capabilities to be applied to attacks.

            AttackCollectionValue attackCollection = (AttackCollectionValue)attackerProx["CurrentAttacks"].GetDataValue();
            int attackDuration = -1;

            AttackCollectionValue.AttackValue newAttack = new AttackCollectionValue.AttackValue(time, attackDuration, targetID, attackerID, capabilityName, percentageApplied, isSelfDefense);
            string errMsg = String.Empty;

            attackDuration = ((IntegerValue)attackerProx["AttackDuration"].GetDataValue()).value;
            int  defenseDuration  = ((IntegerValue)targetProx["EngagementDuration"].GetDataValue()).value;
            int  attackTimeWindow = attackDuration;
            bool attackSuccess    = true;

            if (defenseDuration > 0)
            {
                attackTimeWindow = defenseDuration;
            }
            Console.WriteLine("AttackObject: Attack duration for " + attackerID + " is " + attackDuration.ToString());
            Console.WriteLine("AttackObject: Attack duration for attack is " + attackTimeWindow.ToString());
            newAttack.attackTimeWindow = attackTimeWindow;

            if (attackCollection.AddAttack(newAttack, out errMsg) == false)
            {
                string msg = "The attack between " + attackerID + " and " + targetID + " encountered the following problem: " + errMsg;
                distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
                                                                       time,
                                                                       ((StringValue)(attackerProx["OwnerID"].GetDataValue())).value,
                                                                       msg));
                attackSuccess = false;
            }
            else if (errMsg != String.Empty)
            {
                string msg = "The attack between " + attackerID + " and " + targetID + " encountered the following problem: " + errMsg;
                distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
                                                                       time,
                                                                       ((StringValue)(attackerProx["OwnerID"].GetDataValue())).value,
                                                                       msg));
            }
            else //success
            {
                dv = targetProx["AttackState"].GetDataValue();
                ((StringValue)dv).value = "BEING_ATTACKED";
                targetProx["AttackState"].SetDataValue(dv);

                dv = targetProx["AttackerList"].GetDataValue();
                ((StringListValue)dv).strings.Add(attackerID);
                targetProx["AttackerList"].SetDataValue(dv);
            }



            if (!attackSuccess)
            {
                attackerProx["CurrentAttacks"].SetDataValue(attackCollection); //set below if attackSuccess is true
                return;
            }


            //End new attack logic.


            //
            Vec3D  attackerPosition = new Vec3D((LocationValue)attackerProx["Location"].GetDataValue());
            Vec3D  targetPosition   = new Vec3D((LocationValue)targetProx["Location"].GetDataValue());
            double distance         = attackerPosition.ScalerDistanceTo(targetPosition); //FIX find actual diatance

            int appliedIntensity = -1;
            List <CapabilityValue.Effect> capabilities = attackerCap.GetOrderedEffectsByCapability(capabilityName);

            foreach (CapabilityValue.Effect eff in capabilities)
            {
                if (eff.name == capabilityName && distance <= eff.range)
                {
                    int r = random.Next(0, 100);
                    if (r <= ((int)(eff.probability * 100)))
                    {
                        appliedIntensity           = Convert.ToInt32(Math.Round(((double)eff.intensity * (double)newAttack.percentageApplied / 100), MidpointRounding.AwayFromZero));
                        newAttack.appliedIntensity = appliedIntensity;
                        targetVul.ApplyEffect(eff.name, appliedIntensity, distance, ref random);
                    }
                    //break outside of the if because if the probability failed, you dont want a second chance with a different range.
                    break; //break because we only want to apply the first range found that satisfied the distance restraint
                }
            }
            attackerProx["CurrentAttacks"].SetDataValue(attackCollection);
            targetProx["Vulnerability"].SetDataValue((DataValue)targetVul);


            distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
                                                                   time,
                                                                   ((StringValue)(attackerProx["OwnerID"].GetDataValue())).value,
                                                                   attackerID + " has engaged " + targetID));
            distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
                                                                   time,
                                                                   ((StringValue)(targetProx["OwnerID"].GetDataValue())).value,
                                                                   targetID + " has been engaged by " + attackerID));

            distClient.PutEvent(SimUtility.BuildHistory_AttackerObjectReportEvent(ref simModel,
                                                                                  time,
                                                                                  attackerID,
                                                                                  attackerPosition,
                                                                                  targetID,
                                                                                  targetPosition,
                                                                                  capabilityName,
                                                                                  appliedIntensity));
        }
        private void TimeTick(SimulationEvent e)
        {
            int       oldTime = time;
            DataValue dv      = null;


            //Vec3D curVec = new Vec3D(0, 0, 0);
            //Vec3D destVec = new Vec3D(0, 0, 0);
            //Vec3D velVec = new Vec3D(0, 0, 0);

            Vec3D loc1  = new Vec3D(0, 0, 0);
            Vec3D loc2  = new Vec3D(0, 0, 0);
            Vec3D next1 = new Vec3D(0, 0, 0);
            Vec3D next2 = new Vec3D(0, 0, 0);

            Vec3D vel1 = new Vec3D(0, 0, 0);
            Vec3D vel2 = new Vec3D(0, 0, 0);

            dv   = e["Time"];
            time = ((IntegerValue)dv).value;

            double dTime = ((double)(time - oldTime)) / 1000;
            SimulationObjectProxy obProx1 = null;
            SimulationObjectProxy obProx2 = null;


            List <string> ids = new List <string>(objectProxies.Keys);

            string id1;

            SimulationEvent collision = null;
            double          distance;
            double?         d;

            while (ids.Count > 0)
            {
                id1 = ids[0];
                ids.Remove(id1);


                foreach (string id2 in ids)
                {
                    d = ObjectDistances.GetScalarDistanceBetweenObjects(id1, id2);

                    if (d == null)
                    {
                        // Don't look for collisions if they aren't on the screen
                        continue;
                    }
                    distance = d.Value;

                    double objectSize1 = 0;
                    double objectSize2 = 0;
                    obProx1 = objectProxies[id1];
                    obProx2 = objectProxies[id2];


                    //// Don't look for collisions if they aren't on the screen

                    dv = obProx1["Location"].GetDataValue();
                    //if (!((LocationValue)dv).exists)
                    //{
                    //    continue;
                    //}
                    loc1.Set((LocationValue)dv);
                    dv = obProx2["Location"].GetDataValue();
                    //if (!((LocationValue)dv).exists)
                    //{
                    //    continue;
                    //}
                    loc2.Set((LocationValue)dv);

                    if (((BooleanValue)obProx1["DockedToParent"].GetDataValue()).value)
                    {
                        continue;
                    }
                    if (((BooleanValue)obProx2["DockedToParent"].GetDataValue()).value)
                    {
                        continue;
                    }

                    // Don't look for collisions if they are owned by the same player
                    if (StateDB.physicalObjects[id1].ownerID == StateDB.physicalObjects[id2].ownerID)
                    {
                        continue;
                    }
                    // Don't look for collisions if they are on the same team
                    if (StateDB.physicalObjects[id1].teamName == StateDB.physicalObjects[id2].teamName)
                    {
                        continue;
                    }
                    //Don't look for collisions if they are not hostile
                    if (StateDB.teams.ContainsKey(StateDB.physicalObjects[id1].teamName) &&
                        StateDB.teams.ContainsKey(StateDB.physicalObjects[id2].teamName))
                    {
                        if (!StateDB.teams[StateDB.physicalObjects[id1].teamName].hostility.Contains(StateDB.teams[StateDB.physicalObjects[id2].teamName].id) &&
                            !StateDB.teams[StateDB.physicalObjects[id2].teamName].hostility.Contains(StateDB.teams[StateDB.physicalObjects[id1].teamName].id))
                        {//only continue if both teams are not hostile to one another
                            continue;
                        }
                    }

                    CapabilityValue.Effect eff = null;

                    // check ranges and add objects to target lists for self defense sim
                    CapabilityValue    cap1 = ((CapabilityValue)obProx1["Capability"].GetDataValue());
                    VulnerabilityValue vul1 = ((VulnerabilityValue)obProx1["Vulnerability"].GetDataValue());
                    CapabilityValue    cap2 = ((CapabilityValue)obProx2["Capability"].GetDataValue());
                    VulnerabilityValue vul2 = ((VulnerabilityValue)obProx2["Vulnerability"].GetDataValue());
                    //double distance = loc1.ScalerDistanceTo(loc2);


                    eff = SimUtility.FindCapabilityEffect(cap1, vul2);
                    dv  = obProx1["TargetsInRange"].GetDataValue();
                    //AD: TODO need a "TargetsInSensorRange"? which can drive the ViewPro loops
                    if (eff != null && distance <= eff.range &&
                        ((StringValue)obProx2["State"].GetDataValue()).value != "Dead")
                    {
                        if (!((StringListValue)dv).strings.Contains(id2))
                        {
                            ((StringListValue)dv).strings.Add(id2);
                        }
                    }
                    else
                    {
                        if (((StringListValue)dv).strings.Contains(id2))
                        {
                            ((StringListValue)dv).strings.Remove(id2);
                        }
                    }
                    obProx1["TargetsInRange"].SetDataValue(dv);

                    eff = SimUtility.FindCapabilityEffect(cap2, vul1);
                    dv  = obProx2["TargetsInRange"].GetDataValue();
                    if (eff != null && distance <= eff.range &&
                        ((StringValue)obProx1["State"].GetDataValue()).value != "Dead")
                    {
                        if (!((StringListValue)dv).strings.Contains(id1))
                        {
                            ((StringListValue)dv).strings.Add(id1);
                        }
                    }
                    else
                    {
                        if (((StringListValue)dv).strings.Contains(id1))
                        {
                            ((StringListValue)dv).strings.Remove(id1);
                        }
                    }
                    obProx2["TargetsInRange"].SetDataValue(dv);


                    // Don't look for collisions if they are dead

                    if (((StringValue)obProx1["State"].GetDataValue()).value == "Dead")
                    {
                        continue;
                    }
                    if (((StringValue)obProx2["State"].GetDataValue()).value == "Dead")
                    {
                        continue;
                    }


                    // Don't look for collisions if they are too small to collide

                    dv          = obProx1["Size"].GetDataValue();
                    objectSize1 = ((DoubleValue)dv).value;
                    if (objectSize1 <= 0.000001)
                    {
                        continue;
                    }
                    dv          = obProx2["Size"].GetDataValue();
                    objectSize2 = ((DoubleValue)dv).value;
                    if (objectSize2 <= 0.000001)
                    {
                        continue;
                    }

                    dv = obProx1["Velocity"].GetDataValue();
                    vel1.Set((VelocityValue)dv);
                    dv = obProx2["Velocity"].GetDataValue();
                    vel2.Set((VelocityValue)dv);
                    if (vel1.X == 0 && vel2.X == 0 && vel1.Y == 0 && vel2.Y == 0 && vel1.Z == 0 && vel2.Z == 0)
                    {
                        continue;
                    }

                    next1 = loc1.Add(vel1.Multiply(dTime));
                    next2 = loc2.Add(vel2.Multiply(dTime));

                    if (next1.ScalerDistanceTo(next2) < (objectSize1 + objectSize2))
                    {
                        collision = SimulationEventFactory.BuildEvent(ref simModel, "ObjectCollision");
                        ((StringValue)collision["ObjectID1"]).value = id1;
                        ((StringValue)collision["ObjectID2"]).value = id2;
                        ((IntegerValue)collision["Time"]).value     = time;
                        distClient.PutEvent(collision);
                    }
                }
            }

            /*foreach (string id1 in objectProxies.Keys)
             * {
             *  foreach (string id2 in objectProxies.Keys)
             *  {
             *      if (id1 == id2)
             *      {
             *          continue;
             *      }
             *      obProx1 = objectProxies[id1];
             *      obProx2 = objectProxies[id1];
             *
             *      dv = obProx1["Location"].GetDataValue();
             *      loc1.Set((LocationValue)dv);
             *      dv = obProx2["Location"].GetDataValue();
             *      loc2.Set((LocationValue)dv);
             *
             *  }
             *
             * }*/
        }
Example #8
0
        /*
         * private CapabilityValue.Effect FindCapabilityEffect(CapabilityValue cap, VulnerabilityValue vuln)
         * {
         *  List<string> vulnNames = new List<string>();
         *
         *  foreach (VulnerabilityValue.Transition t in vuln.transitions)
         *  {
         *      foreach (VulnerabilityValue.TransitionCondition tc in t.conditions)
         *      {
         *          if (!vulnNames.Contains(tc.capability))
         *          {
         *              vulnNames.Add(tc.capability);
         *          }
         *      }
         *  }
         *
         *  foreach (CapabilityValue.Effect e in cap.effects)
         *  {
         *      if (vulnNames.Contains(e.name))
         *      {
         *          return e;
         *      }
         *  }
         *  return null;
         * }*/

        private void TimeTick(SimulationEvent e)
        {
            if (objectProxies == null)
            {
                objectProxies = bbClient.GetObjectProxies();
            }
            time = ((IntegerValue)e["Time"]).value;

            DataValue dv = null;

            SimulationObjectProxy obProx = null, targetProx = null;

            Vec3D  myLoc;
            Vec3D  targetLoc;
            string targetID;
            bool   isWeapon = false;
            bool   pursueStarted;

            CapabilityValue    capabilities;
            VulnerabilityValue vulnerabilities;

            CapabilityValue.Effect effect;
            double        distance;
            LocationValue location;

            foreach (string id in objectProxies.Keys)
            {
                obProx = objectProxies[id];

                // update the StateDB info

                if (StateDB.physicalObjects[id].ownerID == "")
                {
                    string owner = ((StringValue)obProx["OwnerID"].GetDataValue()).value;
                    if (StateDB.decisionMakers.ContainsKey(owner))
                    {
                        StateDB.physicalObjects[id].ownerID = owner;
                    }
                }

                if (StateDB.physicalObjects[id].speciesName == "")
                {
                    string speciesName = ((StringValue)obProx["ClassName"].GetDataValue()).value;
                    StateDB.physicalObjects[id].speciesName = speciesName;
                }

                if (StateDB.physicalObjects[id].ownerID != "" && StateDB.physicalObjects[id].teamName == "")
                {
                    if (StateDB.decisionMakers[StateDB.physicalObjects[id].ownerID].team != null)
                    {
                        StateDB.physicalObjects[id].teamName = StateDB.decisionMakers[StateDB.physicalObjects[id].ownerID].team.id;
                    }
                }

                if (((StringValue)obProx["AttackState"].GetDataValue()).value == "BEING_ATTACKED")
                {
                    continue;
                }

                AttackCollectionValue attCV = (AttackCollectionValue)obProx["CurrentAttacks"].GetDataValue();
                if (attCV.GetCurrentSelfDefenseAttacks().Count == 0)
                //if (((StringValue)obProx["AttackTargetID"].GetDataValue()).value == "")
                {
                    dv = obProx["SelfDefenseStartAttack"].GetDataValue();
                    ((BooleanValue)dv).value = false;
                    obProx["SelfDefenseStartAttack"].SetDataValue(dv);

                    dv = obProx["SelfDefenseCapability"].GetDataValue();
                    ((StringValue)dv).value = "";
                    obProx["SelfDefenseCapability"].SetDataValue(dv);

                    dv = obProx["SelfDefenseTargetID"].GetDataValue();
                    ((StringValue)dv).value = "";
                    obProx["SelfDefenseTargetID"].SetDataValue(dv);
                }

                if (((BooleanValue)obProx["SelfDefenseStartAttack"].GetDataValue()).value == true)
                {
                    continue;
                }

                isWeapon      = ((BooleanValue)obProx["IsWeapon"].GetDataValue()).value;
                pursueStarted = ((BooleanValue)obProx["PursueStarted"].GetDataValue()).value;
                targetID      = ((StringValue)obProx["PursueTargetID"].GetDataValue()).value;

                capabilities = (CapabilityValue)obProx["Capability"].GetDataValue();

                if (isWeapon && pursueStarted && objectProxies.ContainsKey(targetID))
                {
                    targetProx = objectProxies[targetID];

                    location = (LocationValue)obProx["Location"].GetDataValue();
                    if (!location.exists)
                    {
                        continue;
                    }
                    myLoc = new Vec3D(location);

                    location = (LocationValue)targetProx["Location"].GetDataValue();
                    if (!location.exists)
                    {
                        continue;
                    }
                    targetLoc = new Vec3D(location);

                    distance = myLoc.ScalerDistanceTo(targetLoc);


                    vulnerabilities = (VulnerabilityValue)targetProx["Vulnerability"].GetDataValue();

                    //string cap = FindCapability(capabilities, vulnerabilities);
                    effect = SimUtility.FindCapabilityEffect(capabilities, vulnerabilities);
                    if (effect != null && distance < effect.range)
                    {
                        dv = obProx["SelfDefenseStartAttack"].GetDataValue();
                        ((BooleanValue)dv).value = true;
                        obProx["SelfDefenseStartAttack"].SetDataValue(dv);

                        dv = obProx["SelfDefenseCapability"].GetDataValue();
                        ((StringValue)dv).value = effect.name;
                        obProx["SelfDefenseCapability"].SetDataValue(dv);

                        dv = obProx["SelfDefenseTargetID"].GetDataValue();
                        ((StringValue)dv).value = targetID;
                        obProx["SelfDefenseTargetID"].SetDataValue(dv);
                    }
                    else if (effect == null && distance < 1)
                    {
                        distClient.PutEvent(SimUtility.BuildStateChangeEvent(ref simModel, time, id, "Dead"));
                    }

                    continue;
                }

                string ownerID = ((StringValue)obProx["OwnerID"].GetDataValue()).value;
                if (StateDB.decisionMakers.ContainsKey(ownerID))
                {
                    StateDB.DecisionMaker thisDM  = StateDB.decisionMakers[ownerID];
                    List <string>         targets = ((StringListValue)obProx["TargetsInRange"].GetDataValue()).strings;

                    //if (targets.Count == 0)
                    //{
                    //    continue;
                    //}
                    foreach (string target in targets)
                    {
                        SimulationObjectProxy obProx2 = objectProxies[target];
                        string ownerID2 = ((StringValue)obProx2["OwnerID"].GetDataValue()).value;
                        if (!StateDB.decisionMakers.ContainsKey(ownerID2))
                        {
                            continue;
                        }
                        StateDB.DecisionMaker thatDM = StateDB.decisionMakers[ownerID2];
                        vulnerabilities = (VulnerabilityValue)obProx2["Vulnerability"].GetDataValue();
                        effect          = SimUtility.FindCapabilityEffect(capabilities, vulnerabilities);

                        if (effect != null && thisDM.isHostile(thatDM) && !thisDM.isHuman)
                        {
                            dv = obProx["SelfDefenseStartAttack"].GetDataValue();
                            ((BooleanValue)dv).value = true;
                            obProx["SelfDefenseStartAttack"].SetDataValue(dv);

                            dv = obProx["SelfDefenseCapability"].GetDataValue();
                            ((StringValue)dv).value = effect.name;
                            obProx["SelfDefenseCapability"].SetDataValue(dv);

                            dv = obProx["SelfDefenseTargetID"].GetDataValue();
                            ((StringValue)dv).value = target;
                            obProx["SelfDefenseTargetID"].SetDataValue(dv);
                            break;
                        }
                    }
                }
            }
        }