示例#1
0
        public RPGEffect(RPGEffect copy)
        {
            range         = copy.range;
            durationType  = copy.durationType;
            targetBuff    = copy.targetBuff;
            targetAttack  = copy.targetAttack;
            effectIsABuff = copy.effectIsABuff;
            trigger       = copy.trigger;
            status        = copy.status;
            location      = copy.location;
            sourceObject  = copy.sourceObject;
            targetObject  = copy.targetObject;

            distance          = copy.distance;
            radius            = copy.radius;
            durationValue     = copy.durationValue;
            minPower          = copy.minPower;
            maxPower          = copy.maxPower;
            m_Power           = copy.Power;
            lastStart         = copy.lastStart;
            lastPause         = copy.lastPause;
            durationRemaining = copy.durationRemaining;
            repeatCount       = copy.repeatCount;
            m_repeatDelay     = copy.m_repeatDelay;
            m_lastRepeat      = copy.m_lastRepeat;
            m_shouldReverse   = copy.m_shouldReverse;
            powerType         = copy.PowerType;
        }
示例#2
0
        void PanelAction_MouseClick(object sender, MouseEventArgs e)
        {
            RPGObject target = Session.thisSession.thisArea.GetObjectAt(e.Location);

            if (target == null)
            {
                // user clicked the ground
                if (e.Button == MouseButtons.Right)
                {
                    LocationRightClick(e.Location);
                }
                else
                {
                    LocationClick(e.Location);
                }
            }
            else
            {
                // then user selected this object
                if (e.Button == MouseButtons.Right)
                {
                    ObjectRightClick(target);
                }
                else
                {
                    ObjectClick(target);
                }
            }
        }
示例#3
0
        private void TargetObjectWithItemAction(ActionButton btn, RPGObject target)
        {
            TargetGroundWithItemAction(btn, target.Location);

            // use the button item on the target
            // do the effects.
            //foreach (RPGEffect effect in btn.Item.Effects)
            //{
            //    if (effect == null)
            //    {
            //        continue;
            //    }

            //    // make sure the target matches the requirements
            //    if (effect.IsCorrectTarget(SelectedObject, target))
            //    {
            //        target.AddEffect(effect);
            //        Session.Print((SelectedObject as Actor).Name + " used " + btn.Item.Name);

            //        // assuming a potion for now, the item gets consumed.
            //        (SelectedObject as Actor).inventory.RemoveQuickItem(btn.Item);
            //        btn.ClearItem();
            //    } // end if good target
            //}
        }
示例#4
0
        public int DistanceBetween(RPGObject a, Point p)
        {
            // closest edge of actor to point

            int dX;
            int dY;

            if (a.X > p.X)
            {
                dX = Math.Abs(a.X - p.X);
            }
            else if (a.X + a.Width < p.X)
            {
                dX = Math.Abs(p.X - a.X - a.Width);
            }
            else
            {
                dX = Math.Abs(a.X - p.X);
            }

            if (a.Y > p.Y)
            {
                dY = Math.Abs(a.Y - p.Y);
            }
            else if (a.Y + a.Height < p.Y)
            {
                dY = Math.Abs(p.Y - a.Y - a.Height);
            }
            else
            {
                dY = Math.Abs(a.Y - p.Y);
            }

            return((int)Math.Sqrt((dX * dX) + (dY * dY)));
        }
示例#5
0
 public bool ObjectOnPoint(RPGObject obj, Point p)
 {
     return(obj.X <= p.X &&
            obj.X + obj.Width >= p.X &&
            obj.Y <= p.Y &&
            obj.Y + obj.Height >= p.Y);
 }
示例#6
0
        public void SetGroundItemsToActionPanel()
        {
            // get the items from the ground grid, and create a new item
            if (groundItems != null &&
                groundItems.Count > 0)
            {
                // create a new item drop object
                RPGDrop newDrop = new RPGDrop();
                int     X       = thisActor.Location.X;
                int     Y       = thisActor.Location.Y + 40; // +40 to look like ground.
                newDrop.Location = new Point(X, Y);

                for (int i = groundItems.Count - 1; i >= 0; i--)
                {
                    // get each item from the ground collection
                    RPGObject obj = groundItems[i] as RPGObject;

                    // set its location to the current actor
                    obj.Location = newDrop.Location;

                    // add it to the drop item
                    newDrop.AddItem(obj);

                    // and remove this item from the groundItems collection
                    groundItems.Remove(obj);
                }
                // add the item to the actionPanel's items.
                Session.thisSession.thisArea.AddObject(newDrop);
            }
        }
示例#7
0
        public FormItemDetails(RPGObject item)
        {
            thisItem = item;
            InitializeComponent();

            this.lbl_Name.Text   = item.Name;
            this.tb_Details.Text = CreateDetailText();
        }
示例#8
0
        public bool ActorStandingNearPoint(RPGObject obj, Point p)
        {
            // point p has been adjusted already, use straight
            bool inX = (Math.Abs(obj.X - p.X) <= Math.Abs(obj.VX));
            bool inY = (Math.Abs(obj.Y - p.Y) <= Math.Abs(obj.VY));

            return(inX && inY);
        }
示例#9
0
        public bool ObjectsCollide(RPGObject a, RPGObject b)
        {
            Rectangle intersection
                = Rectangle.Intersect(new Rectangle(a.Location, a.Size),
                                      new Rectangle(b.Location, b.Size));

            return(intersection.IsEmpty == false);
        }
示例#10
0
 public RPGAction(ActionType t, RPGObject targetObject)
 {
     type            = t;
     NeedsUpdating   = true;
     UpdateFrequency = DEFAULT_UPDATE_FREQUENCY;
     lastUpdate      = DateTime.Now;
     target          = targetObject;
     destination     = targetObject.Location;
 }
示例#11
0
        public bool IsCorrectTarget(RPGObject source, RPGObject target, Point targetLocation)
        {
            if (source == null || target == null)
            {
                return(false);
            }

            bool    result = false;
            RPGCalc calc   = new RPGCalc();

            switch (range)
            {
            case (EffectRange.Self):
            {
                result = (source == target);
                break;
            }

            case (EffectRange.Target):
            {
                // target is roughly at location
                result = calc.ObjectOnPoint(target, targetLocation);
                break;
            }

            case (EffectRange.Touch):
            {
                // target within touch distance
                int d = calc.DistanceBetween(source, target);
                result = (d <= RPGCalc.DEFAULT_TOUCH_RANGE);
                break;
            }

            case (EffectRange.Area):
            {
                // target within item distance
                int d = calc.DistanceBetween(source, target);
                result = (d <= this.distance);
                break;
            }

            case (EffectRange.TargetArea):
            {
                // target within item distance and radius
                int d = calc.DistanceBetween(target, targetLocation);
                result = (d <= this.radius);
                break;
            }

            default:
            {
                break;
            }
            } // end switch
            return(result);
        }
示例#12
0
        private bool AddItemToQuick(RPGObject item)
        {
            bool result = false;

            if (item != null && item.isOfType(typeof(RPGItem)))
            {
                result = thisActor.inventory.AddQuickItem(item as RPGItem);
                LoadQuickGrid(thisActor);
            }
            return(result);
        }
示例#13
0
        private bool AddItemToPack(RPGObject item)
        {
            bool result = false;

            if (item != null && thisActor.inventory.AddItem(item))
            {
                LoadPackGrid(thisActor);
                result = true;
            }
            return(result);
        }
示例#14
0
 public void RemoveObject(RPGObject obj)
 {
     for (int i = 0; i < RPGObjects.Length; i++)
     {
         if (RPGObjects[i] != null)
         {
             if (RPGObjects[i] == obj)
             {
                 RPGObjects[i] = null;
                 return;
             }
         }
     }
 }
示例#15
0
        void btnEquip_Click(object sender, EventArgs e)
        {
            // move selected pack item to body, at correct slot
            // if already equipped, then switch locations.
            RPGObject item = GetSelectedItemFromPack();

            // now, check if body already has an item at that slot
            if (item == null)
            {
                MessageBox.Show("No item selected from pack to equip.");
                return;
            }
            else if (item.isOfType(typeof(RPGItem)) == false)
            {
                MessageBox.Show("This item type cannot be equipped.");
                return;
            }
            else
            {
                // check if destination slot is already filled
                if (thisActor.inventory.GetBodyItem(((RPGItem)item).Slot) != null)
                {
                    // find currently equipped item and remove it
                    RPGItem currentlyEquippedItem
                        = thisActor.inventory.GetBodyItem(((RPGItem)item).Slot);

                    if (AddItemToPack(currentlyEquippedItem))
                    {
                        RemoveItemFromBody(currentlyEquippedItem);
                    }
                    else
                    {
                        MessageBox.Show("Unable to add equipped item back into pack.");
                        return;
                    }
                } // end it slot is already filled
                else
                {
                    // add new item to body
                    if (AddItemToBody(((RPGItem)item), ((RPGItem)item).Slot))
                    {
                        RemoveItemFromPack(item);
                    }
                    else
                    {
                        MessageBox.Show("Unable to equip item.");
                    }
                } // end else - destination slot empty
            }     // end else - item ok
        }
示例#16
0
        public RPGObject RemovePackItem(int packSlotIndex)
        {
            RPGObject obj = GetPackItem(packSlotIndex);

            if (obj != null)
            {
                PackItems[packSlotIndex] = null;
                return(obj);
            }
            else
            {
                return(null);
            }
        }
示例#17
0
 private void LocationClick(Point loc)
 {
     if (SelectedObject == null)
     {
         // then user has chosen to click on the ground for some reason...
         GroundClicked(loc);
     }
     else
     {
         // then user has selected the ground, unselect our current object
         SelectedObject.IsSelected = false;
         SelectedObject            = null;
     }
 }
示例#18
0
        private void RemoveItemFromPack(RPGObject item)
        {
            // since the item can be anywhere, check all of them.

            for (int i = 0; i < Inventory.PACK_SIZE; i++)
            {
                if (thisActor.inventory.GetPackItem(i) == item)
                {
                    thisActor.inventory.RemovePackItem(i);
                    break;
                }
            }

            LoadPackGrid(thisActor);
        }
示例#19
0
        private void LoadPackRow(RPGObject item)
        {
            if (item == null)
            {
                return;
            }
            DataRow row = dtPackItems.NewRow();

            row[0] = item.Name;
            row[1] = GetItemType(item);
            if (item.isOfType(typeof(RPGItem)))
            {
                row[2] = (item as RPGItem).Description;
            }
            dtPackItems.Rows.Add(row);
        }
示例#20
0
        public int DistanceBetween(RPGObject a, RPGObject b)
        {
            int dX = Math.Abs(a.X - b.X);
            int dY = Math.Abs(a.Y - b.Y);

            if (dX > a.Width)
            {
                dX -= a.Width;
            }
            if (dY > a.Height)
            {
                dY -= a.Height;
            }

            return((int)Math.Sqrt((dX * dX) + (dY * dY)));
        }
示例#21
0
        /// <summary>
        /// Calculates the location (Point) that is towards the target
        /// in order to be within the given range
        /// </summary>
        /// <param name="source"></param>
        /// <param name="Range"></param>
        /// <param name="target"></param>
        /// <returns></returns>
        public Point PointToBeInRange(Actor source, int Range, RPGObject target)
        {
            // so, use the distance between and the actor's range to figure where the point needs to be.

            int distanceX = target.X - source.X;
            int distanceY = target.Y - source.Y;

            int diagDistance = (int)Math.Sqrt(distanceX * distanceX + distanceY * distanceY);

            // diagDistance is the entire distance between the two, we only need enough to get in range.

            diagDistance -= Range;

            // now diagDistance is the distance between source and target IN RANGE

            double angle = Math.Atan((double)distanceY / (double)distanceX);

            int changeX = (int)(Math.Cos(angle) * diagDistance * 1.1); // 1.1 = get inside range
            int changeY = (int)(Math.Sin(angle) * diagDistance * 1.1);

            // sometimes the x value turns out backwards, so make a general
            // sweeping assumption to check for the correct direction.
            if (source.X > target.X)
            {
                // changeX needs to be negative
                changeX = -Math.Abs(changeX);
            }
            else if (source.X < target.X)
            {
                // changeX needs to be postive
                changeX = Math.Abs(changeX);
            }

            // check the y value too.
            if (source.Y > target.Y)
            {
                // changeY needs to be negative
                changeY = -Math.Abs(changeY);
            }
            else if (source.Y < target.Y)
            {
                // changeY needs to be positive
                changeY = Math.Abs(changeY);
            }

            return(new Point(source.X + changeX, source.Y + changeY));
        }
示例#22
0
        void btnPickup_Click(object sender, EventArgs e)
        {
            // move selected ground item to pack
            RPGObject item = GetSelectedItemFromGround();

            if (item == null)
            {
                MessageBox.Show("No item selected from ground.");
            }
            else if (AddItemToPack(item))
            {
                RemoveItemFromGround(item);
            }
            else
            {
                MessageBox.Show("unable to pick up item from ground.");
            }
        }
示例#23
0
        void btnQuickRemove_Click(object sender, EventArgs e)
        {
            // move selected ground item to pack
            RPGObject item = GetSelectedItemFromQuick();

            if (item == null)
            {
                MessageBox.Show("No item selected from pack ");
            }
            else if (AddItemToPack(item))
            {
                RemoveItemFromQuick(item);
            }
            else
            {
                MessageBox.Show("Could not move item from quick to pack.");
            }
        }
示例#24
0
        void btnQuickAdd_Click(object sender, EventArgs e)
        {
            // move selected pack item to ground
            RPGObject item = GetSelectedItemFromPack();

            if (item == null)
            {
                MessageBox.Show("No item selected from pack to add to quick items.");
            }
            else if (AddItemToQuick(item))
            {
                RemoveItemFromPack(item);
            }
            else
            {
                MessageBox.Show("Could not add item to Quick Items");
            }
        }
示例#25
0
        void btnDrop_Click(object sender, EventArgs e)
        {
            // move selected pack item to ground
            RPGObject item = GetSelectedItemFromPack();

            if (item == null)
            {
                MessageBox.Show("No item selected from the pack to drop.");
            }
            else if (AddItemToGround(item))
            {
                RemoveItemFromPack(item);
            }
            else
            {
                MessageBox.Show("Unable to drop item to ground.");
            }
        }
示例#26
0
        public bool AddObject(RPGObject obj)
        {
            int s = GetObjSlot();

            if (s > -1)
            {
                RPGObjects[s] = obj;
                if (obj.isOfType(typeof(Actor)))
                {
                    (obj as Actor).ResetStats();
                }
                return(true);
            }
            else
            {
                return(false);
            }
        }
示例#27
0
 private void ObjectRightClick(RPGObject obj)
 {
     if (SelectedObject == null)
     {
         // right click something first?
     }
     else
     {
         //if (SelectedObject != obj)
         //{
         //    // right clicked a different object
         TargetObject(obj);
         //}
         //else
         //{
         //    // right clicked same object again?
         //}
     }
 }
示例#28
0
        private RPGObject GetSelectedItemFromPack()
        {
            if (dgvPack.SelectedRows.Count != 1)
            {
                return(null);
            }

            string selDesc = dgvPack.SelectedRows[0].Cells[2].Value.ToString();

            for (int i = 0; i < Inventory.PACK_SIZE; i++)
            {
                RPGObject item = thisActor.inventory.GetPackItem(i);
                if (item != null && (item as RPGItem).Description == selDesc)
                {
                    return(item);
                }
            }

            return(null);
        }
示例#29
0
 public bool AddItem(RPGObject obj)
 {
     if (obj.isOfType(typeof(RPGDrop)))
     {
         RPGObject[] objs = ((RPGDrop)obj).GetItems();
         for (int i = 0; i < objs.Length; i++)
         {
             AddItem((RPGItem)objs[i]);
         }
         return(true);
     }
     else if (obj.isOfType(typeof(RPGItem)))
     {
         return(AddPackItem((RPGItem)obj));
     }
     else
     {
         // don't recognize item type.
         return(false);
     }
 }
示例#30
0
        private string GetItemType(RPGObject item)
        {
            // set 'type' conditionally.
            string type = item.GetType().ToString();

            switch (type)
            {
            case ("RPG.RPGWeapon"):
            {
                // then get the weapon class/type
                return(Enum.GetName(typeof(RPGWeapon.WeaponClass), ((RPGWeapon)item).weaponClass));
                //break;
            }

            case ("RPG.Projectile"):
            {
                return(Enum.GetName(typeof(Projectile.ProjectileType), ((Projectile)item).type));
                //break;
            }

            case ("RPG.RPGArmor"):
            {
                // then get the armor class/type
                return(Enum.GetName(typeof(RPGArmor.ArmorClass), ((RPGArmor)item).Class));
                //break;
            }

            case ("RPG.RPGPotion"):
            {
                return("Potion");
                //break;
            }

            default:
            {
                return(type);
            }
            } // end switch
        }