Example #1
0
        private bool MovingSkill(TileNode endNode, List <TileNode> allNodeList, AreaOrder areaOrder, WalkOrder walkOrder)
        {
            if (endNode == null)
            {
                print("EndNode : " + endNode);
                return(false);
            }

            var enemy = enemyAi.currentEnemy;

            if (enemy == null)
            {
                print("Enemy : " + enemy);
                return(false);
            }

            var startNode = allNodeList.Find(i => i.Coordinate == GameUtility.Coordinate(enemy.transform.position));

            if (startNode == null)
            {
                print("StartNode : " + startNode);
                return(false);
            }

            var way = _board.PathFinding.GreedPathFinding(startNode, endNode, _board.NodeList);

            if (way == null)
            {
                return(false);
            }

            enemy.enemyMove.IndicateUnit(way, areaOrder, walkOrder);
            return(true);
        }
Example #2
0
        // start
        public void IndicateUnit(List <TileNode> way, AreaOrder areaOrder, WalkOrder walkOrder)
        {
            int spendVigor;

            if (areaOrder == AreaOrder.Base)
            {
                spendVigor = _enemy.enemyAi.halfVigor;
            }
            else if (areaOrder == AreaOrder.Double)
            {
                spendVigor = _enemy.enemyAi.fullVigor;
            }
            else
            {
                spendVigor = _enemy.enemyAi.halfVigor;
            }
            way.Reverse();
            StartCoroutine(Indicator(MakeTransform(way), spendVigor, walkOrder));
        }
Example #3
0
        public bool UnitWalk(AreaOrder areaOrder, WalkOrder walkOrder, TileNode endNode)
        {
            TileNode newNode = endNode;

            if (walkOrder == WalkOrder.Random)
            {
                var areaList = new List <TileNode>();

                if (areaOrder == AreaOrder.Base)
                {
                    moveBaseArea.SetActive(true);
                }
                else if (areaOrder == AreaOrder.Double)
                {
                    moveDoubleArea.SetActive(true);
                }
                else
                {
                    print("Wrong order for RandomWalk");
                }

                foreach (var node in _board.NodeList)
                {
                    if (Physics.CheckBox(node.transform.position, GameUtility.Box, Quaternion.identity, LayerMask.GetMask("Obstacle", "Player", "Enemy")))
                    {
                        continue;
                    }
                    if (areaOrder == AreaOrder.Base)
                    {
                        if (Physics.CheckBox(node.transform.position, GameUtility.Box, Quaternion.identity, LayerMask.GetMask("MoveBaseArea")))
                        {
                            node.tileStyle = TileStyle.OneArea;
                            areaList.Add(node);
                        }
                    }
                    else if (areaOrder == AreaOrder.Double)
                    {
                        if (Physics.CheckBox(node.transform.position, GameUtility.Box, Quaternion.identity, LayerMask.GetMask("MoveDoubleArea")))
                        {
                            node.tileStyle = TileStyle.TwoArea;
                            areaList.Add(node);
                        }
                    }
                }

                int randomNumber = Random.Range(0, areaList.Count - 1);
                newNode = areaList[randomNumber];

                if (areaOrder == AreaOrder.Base)
                {
                    moveBaseArea.SetActive(false);
                }
                else if (areaOrder == AreaOrder.Double)
                {
                    moveDoubleArea.SetActive(false);
                }
            }

            else if (walkOrder == WalkOrder.Base || walkOrder == WalkOrder.Rush)
            {
                newNode = endNode;
            }

            var canMove = MovingSkill(newNode, _board.NodeList, areaOrder, walkOrder);

            return(canMove);
        }
        public void CreateAreaOrder()
        {
            try
            {
                _logger.Info($"run at{DateTime.Now}");
                using (var db = new ShoppingSchedulerContext())
                {
                    var setting = db.Settings.First();
                    if (setting == null)
                    {
                        return;
                    }
                    var now          = DateTime.Now;
                    var date         = DateTime.Parse("2019/05/19");
                    var ordersExpire = db.PrivateOrder.Where(p => p.CreationTime >= date &&
                                                             p.OrderStatus == OrderStatus.Pending && p.ExpireOpenTime < now &&
                                                             p.IsConvertToAreaOrder == false).ToList();

                    foreach (var order in ordersExpire)
                    {
                        var shopsInArea = db.Shops.Where(item =>
                                                         item.IsActive && item.ShopStatus == ShopStatus.Accept && item.Id != order.Shop.Id &&
                                                         item.ShopAddress.Geography.Distance(order.OrderAddress.Geography) <= item.AreaRadius)
                                          .ToList();
                        if (shopsInArea.Count < 1)
                        {
                            order.IsConvertToAreaOrder = true;
                            db.SaveChanges();
                            continue;
                        }

                        var expireOpenTime = DateTime.Now.AddSeconds(setting.OrderExpireOpenTime);
                        var orderItems     = order.OrderItems.ToList();

                        foreach (var shop in shopsInArea)
                        {
                            var areaOrder = new AreaOrder(order.Customer, order.OrderAddress,
                                                          order.Description,
                                                          expireOpenTime, shop, order, AreaOrderCreator.ByScheduler)
                            {
                                OrderItems = new List <OrderItem>()
                            };
                            foreach (var orderItem in orderItems)
                            {
                                var orderProductTemp = new OrderProduct(orderItem.OrderProduct.ProductId,
                                                                        orderItem.OrderProduct.Name, orderItem.OrderProduct.Price,
                                                                        orderItem.OrderProduct.ProductImage, orderItem.OrderProduct.BrandId,
                                                                        orderItem.OrderProduct.BrandName);
                                OrderItemDiscountBase orderItemDiscountBase = null;
                                if (orderItem.Discount != null)
                                {
                                    orderItemDiscountBase = orderItem.Discount;
                                }

                                var orderItemTemp = new OrderItem(Guid.NewGuid(), orderItem.Quantity,
                                                                  orderItem.Description,
                                                                  orderProductTemp, orderItemDiscountBase);

                                areaOrder.OrderItems.Add(orderItemTemp);
                            }
                            db.AreaOrder.Add(areaOrder);
                            _fcmNotification.SendToIds(shop.GetPushTokens(), "سفارش جدید",
                                                       $"یک سفارش ثبت شد", NotificationType.OrderAdd,
                                                       AppType.Shop, NotificationSound.Shopper);
                        }
                        order.IsConvertToAreaOrder = true;
                        db.SaveChanges();
                    }
                }
            }
            catch (Exception e)
            {
                _logger.Info($"exception run at{DateTime.Now}");
                _logger.Error(JsonConvert.SerializeObject(e));
            }
        }
        public async Task <ConvertPrivateToAreaOrderCommandResponse> Handle(ConvertPrivateToAreaOrderCommand command)
        {
            var setting = await _applicationSettingRepository.AsQuery().FirstOrDefaultAsync();

            if (setting == null)
            {
                throw new Exception();
            }
            var order = await _privateOrderRepository.FindAsync(command.OrderId);

            if (order == null)
            {
                throw new DomainException("سفارش یافت نشد");
            }

            var areaOrders = _areaRepository.AsQuery().Where(p => p.PrivateOrder.Id == order.Id).ToList();

            foreach (var areaOrder in areaOrders)
            {
                areaOrder.OrderItems.Clear();
                _areaRepository.Remove(areaOrder);
            }

            var shopsInArea = _personRepository.AsQuery().OfType <Shop>().Where(item =>
                                                                                item.Id != order.Shop.Id && item.IsActive && item.ShopStatus == ShopStatus.Accept &&
                                                                                item.ShopAddress.Geography.Distance(order.OrderAddress.Geography) <= item.AreaRadius)
                              .ToList();

            if (shopsInArea.Count <= 1)
            {
                throw new DomainException("فروشگاه دیگری در اطراف این فرو شگاه موجود نمی باشد");
            }
            var orderItems = order.OrderItems.ToList();
            var areaOrderExpireOpenTime = DateTime.Now.AddSeconds(setting.OrderExpireOpenTime);

            foreach (var shop in shopsInArea)
            {
                var areaOrder = new AreaOrder(order.Customer, order.OrderAddress,
                                              order.Description,
                                              areaOrderExpireOpenTime, shop, order, AreaOrderCreator.ByCustomer)
                {
                    OrderItems = new List <OrderItem>()
                };
                foreach (var orderItem in orderItems)
                {
                    var orderProductTemp = new OrderProduct(orderItem.OrderProduct.ProductId,
                                                            orderItem.OrderProduct.Name, orderItem.OrderProduct.Price,
                                                            orderItem.OrderProduct.ProductImage, orderItem.OrderProduct.BrandId,
                                                            orderItem.OrderProduct.BrandName);
                    OrderItemDiscountBase orderItemDiscountBase = null;
                    if (orderItem.Discount != null)
                    {
                        orderItemDiscountBase = orderItem.Discount;
                    }
                    var orderItemTemp = new OrderItem(Guid.NewGuid(), orderItem.Quantity, orderItem.Description,
                                                      orderProductTemp, orderItemDiscountBase);
                    areaOrder.OrderItems.Add(orderItemTemp);
                }
                _areaRepository.Add(areaOrder);
                await _fcmNotification.SendToIds(shop.GetPushTokens(), "سفارش جدید",
                                                 $"یک سفارش ثبت شد", NotificationType.OrderAdd,
                                                 AppType.Shop, NotificationSound.Shopper);
            }
            order.IsConvertToAreaOrder = true;
            order.OrderStatus          = OrderStatus.Pending;
            order.ExpireOpenTime       = DateTime.Now.AddSeconds(setting.OrderExpireOpenTime);
            return(new ConvertPrivateToAreaOrderCommandResponse(setting.OrderExpireOpenTime));
        }
Example #6
0
 public Area()
 {
     DrawOrdering = AreaOrder.SelfFirst;
     Style        = Style.Default;
 }