Example #1
0
        public async Task <bool> StartMining(DBKey userId)
        {
            if (userId == GlobalDefine.INVALID_DBKEY)
            {
                return(false);
            }

            UserBasicData userBasicData = new UserBasicData();

            if (await userBasicData.FromDBAsync(userId) == false)
            {
                return(false);
            }

            lock (Items)
            {
                if (Items.ContainsKey(userId))
                {
                    return(false);
                }

                var miningData = new MiningData()
                {
                    UserId         = userId,
                    NextMiningTime = DateTime.UtcNow.AddSeconds(RandomEx.Range(MiningTimeRange.min.TotalSeconds, MiningTimeRange.max.TotalSeconds)),
                    LastMiningTime = DateTime.UtcNow,
                };
                miningData.RefreshSessionExpireTime();

                Items.Add(userId, miningData);
            }
            return(true);
        }
Example #2
0
    protected virtual void Update()
    {
        GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);

        cube.transform.position    = RandomEx.OnUnitSphere() * 5;
        cube.transform.localScale *= RandomEx.Value;

        GameObject.Destroy(cube, RandomEx.Range(0, 1.5f));
    }
Example #3
0
    protected void Update()
    {
        if (!Input.GetKeyDown(this.generateKey))
        {
            return;
        }

        int index = RandomEx.Index(this.primitiveRates);

        GameObject newObject = GameObject.CreatePrimitive(this.primitiveTypes[index]);

        GameObject.Destroy(newObject, RandomEx.Range(0.2f, 0.5f));

        this.generateCount[index] += 1;
    }
Example #4
0
        protected override void OnUpdateService(double deltaTimeSec)
        {
            if (Items.Count_LockThis() == 0)
            {
                return;
            }

            var utcNow = DateTime.UtcNow;
            var items  = Items.ToArrayValue_LockThis();

            List <DBQuery> queries = new List <DBQuery>();

            foreach (var it in items)
            {
                if (utcNow >= it.NextMiningTime)
                {
                    it.LastMiningTime = utcNow;
                    it.NextMiningTime = utcNow.AddSeconds(RandomEx.Range(MiningTimeRange.min.TotalSeconds, MiningTimeRange.max.TotalSeconds));

                    var miningAmount = RandomEx.Range(MiningAmountRange.min, MiningAmountRange.max);

                    var miningHistoryQuery = new DBQuery_MiningHistory_Insert();
                    var item = miningHistoryQuery.IN.Item;
                    item.MiningHistoryId = IDGenerator.NewMiningHistoryId;
                    item.UserId          = it.UserId;
                    item.CurrencyType    = CurrencyTypes.HENA_MINING;
                    item.MiningAmount    = miningAmount;
                    item.MiningTime      = utcNow;
                    queries.Add(miningHistoryQuery);

                    var balanceAddQuery = new DBQuery_Balance_Add();
                    balanceAddQuery.IN.UserId       = it.UserId;
                    balanceAddQuery.IN.CurrencyType = CurrencyTypes.HENA_MINING;
                    balanceAddQuery.IN.Amount       = miningAmount;
                    queries.Add(balanceAddQuery);
                }

                if (utcNow > it.ExpireTime)
                {
                    StopMining(it.UserId);
                }
            }

            DBThread.Instance.ReqQuery(queries.ToArray());
        }
Example #5
0
 private void PlayBump()
 {
     MediaPlayer.Play(bump_sfx, 0f, RandomEx.Range(0.1f, 1.0f));
 }
Example #6
0
        public async Task <IActionResult> AdReady([FromBody] PageAdModels.AdReady.Request request)
        {
            if (request == null || request.IsValidParameters() == false)
            {
                return(APIResponse(ErrorCode.InvalidParameters));
            }

            // Check Data
            AdInfo ai = new AdInfo();

            if (await ai.AdUnitData.FromDBAsync(request.AdUnitId) == false ||
                await ai.AppData.FromDBAsync(ai.AdUnitData.AppId) == false)
            {
                return(APIResponse(ErrorCode.BadRequest));
            }

            if (ai.AdUnitData.AdSystemType != request.AdSystemType)
            {
                return(APIResponse(ErrorCode.InvalidParameters));
            }


            var supportedDesignTypes = AdDesignTypes.ToSupported(request.ClientType, request.AdSystemType, request.IsLandscape);

            bool isFound = false;

            for (int i = 0; i < 3; ++i)
            {
                var adDesignType = supportedDesignTypes[RandomEx.Range(0, supportedDesignTypes.Length)];
                if (await ai.AdDesignData.ChoiceFromDBAsync(adDesignType) &&
                    await ai.CampaignData.FromDBAsync(ai.AdDesignData.CampaignId) &&
                    await ai.AdResourceData.FromDBAsync(ai.AdDesignData.AdResourceId)
                    )
                {
                    isFound = true;
                    break;
                }
            }

            if (isFound == false)
            {
                return(APIResponse(ErrorCode.NotFound));
            }

            // Insert to db
            var insertQuery = new DBQuery_AdHistory_Insert();
            var ahd         = ai.AdHistoryData = insertQuery.IN.Item;

            ahd.AdHistoryId = IDGenerator.NewAdHistoryId;

            UserBasicData customerData = new UserBasicData();

            if (request.CustomerId != GlobalDefine.INVALID_DBKEY &&
                await customerData.FromDBAsync(request.CustomerId))
            {
                ahd.CustomerId = request.CustomerId;
            }
            else
            {
                ahd.CustomerId = GlobalDefine.INVALID_DBKEY;
            }

            ahd.PublisherId = ai.AdUnitData.UserId;
            ahd.AppId       = ai.AdUnitData.AppId;
            ahd.AdUnitId    = ai.AdUnitData.AdUnitId;

            ahd.AdvertiserId = ai.CampaignData.UserId;
            ahd.AdDesignId   = ai.AdDesignData.AdDesignId;
            ahd.CampaignId   = ai.CampaignData.CampaignId;

            ahd.UserAgent = UserAgent;
            ahd.IPAddress = RemoteIPAddress;

            ahd.AdDesignType = ai.AdDesignData.AdDesignType;
            ahd.CampaignType = ai.CampaignData.CampaignType;
            ahd.Cost         = ai.CampaignData.Cost;

            if (await DBThread.Instance.ReqQueryAsync(insertQuery) == false)
            {
                return(APIResponse(ErrorCode.DatabaseError));
            }

            // Response
            var response = new PageAdModels.AdReady.Response();

            response.AdUnitId     = request.AdUnitId;
            response.AdSystemType = ai.AdUnitData.AdSystemType;
            response.AdDesignType = ai.AdDesignData.AdDesignType;

            response.ContentType = ai.AdResourceData.ContentType;
            var resourceUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}{Url.Action("AdResource", "PageAd")}";

            response.ResourceUrl = resourceUrl;

            response.Width  = ai.AdResourceData.Width;
            response.Height = ai.AdResourceData.Height;

            response.AdUrl = ai.AdDesignData.DestinationUrl;

            response.AdClickUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}{Url.Action("AdClick", "PageAd")}";

            response.Ai = ai.Encode().EncodeBase64ToUrlSafeBase64();
            return(Success(response));
        }