Merge branch 'master' of 60.1.1.230:backend/jieling_server

back_recharge
wangyuan 2019-08-01 10:10:28 +08:00
commit cf006d2184
21 changed files with 1004 additions and 245 deletions

View File

@ -8,3 +8,5 @@ int string int string string int
6 成长基金 6 0 0 1
7 云梦祈福 7 0 604800 2
8 孙龙的宝藏 8 0 604800 2
9 招财猫 9 0 604800 2
10 七日狂欢 10 0 604800 2

View File

@ -0,0 +1,10 @@
Id ActivityId LuckyType LuckyTime ConsumeValue ValueUp ValueDown RmbValue
int int int int int int int int
1 9 16 1 200 300 200 0
2 9 16 2 500 750 500 0
3 9 16 3 1000 1200 1000 0
4 9 16 4 2000 2400 2000 100
5 9 16 5 3000 3600 3000 500
6 9 16 6 4000 4800 4000 1000
7 9 16 7 5000 6000 5000 1500
8 9 16 8 6000 7200 6000 2000

View File

@ -0,0 +1,78 @@
package com.ljsd.jieling.config;
import com.ljsd.jieling.logic.STableManager;
import com.ljsd.jieling.logic.Table;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
@Table(name = "LuckyCatConfig")
public class SLuckyCatConfig implements BaseConfig {
private int id;
private int activityId;
private int luckyType;
private int luckyTime;
private int consumeValue;
private int valueUp;
private int valueDown;
private int rmbValue;
public static Map<Integer, SLuckyCatConfig> configMap = new TreeMap<>();
private static Map<Integer, Integer> miss2times = new HashMap<>();
@Override
public void init() throws Exception {
configMap = new TreeMap<>(STableManager.getConfig(SLuckyCatConfig.class));
int lastTimes = 0;
for (Map.Entry<Integer, SLuckyCatConfig> item : configMap.entrySet()) {
miss2times.put(item.getKey(), item.getValue().getLuckyTime() - lastTimes);
lastTimes = item.getValue().getLuckyTime();
}
}
public int getId() {
return id;
}
public int getActivityId() {
return activityId;
}
public int getLuckyType() {
return luckyType;
}
public int getLuckyTime() {
return luckyTime;
}
public int getConsumeValue() {
return consumeValue;
}
public int getValueUp() {
return valueUp;
}
public int getValueDown() {
return valueDown;
}
public int getRmbValue() {
return rmbValue;
}
public static Integer getMiss2time(int luckyTime) {
return miss2times.containsKey(luckyTime) ? miss2times.get(luckyTime) : 0;
}
}

View File

@ -111,6 +111,7 @@ public interface BIReason {
int BLESS_CHOOSE_CONSUME = 1028;
int BUY_TREASURE_CONSUME = 1029;
int LUCKYCAT_CONSUME = 1030;
int CREATE_GUILD_CONSUME = 1030; // 创建宗门消耗

View File

@ -1,14 +1,17 @@
package com.ljsd.jieling.handler;
import com.ljsd.jieling.logic.activity.AbstractActivity;
import com.ljsd.jieling.logic.activity.ActivityLogic;
import com.ljsd.jieling.logic.activity.ActivityTypeEnum;
import com.ljsd.jieling.netty.cocdex.PacketNetData;
import com.ljsd.jieling.network.session.ISession;
import com.ljsd.jieling.protocols.MessageTypeProto;
import com.ljsd.jieling.protocols.PlayerInfoProto;
import com.ljsd.jieling.util.MessageUtil;
import org.springframework.stereotype.Component;
@Component
public class TakeActivityRewardHandler extends BaseHandler{
public class TakeActivityRewardHandler extends BaseHandler {
@Override
public MessageTypeProto.MessageType getMessageCode() {
return MessageTypeProto.MessageType.TAKE_ACTIVITY_REWARD_REQUEST;
@ -20,6 +23,12 @@ public class TakeActivityRewardHandler extends BaseHandler{
PlayerInfoProto.TakeActivityRewardRequest takeActivityRewardRequest = PlayerInfoProto.TakeActivityRewardRequest.parseFrom(bytes);
int missionId = takeActivityRewardRequest.getMissionId();
int activityId = takeActivityRewardRequest.getActivityId();
ActivityLogic.getInstance().takeReward(iSession,activityId,missionId);
AbstractActivity abstractActivity = ActivityTypeEnum.getActicityType(activityId, iSession.getUid());
if (abstractActivity == null) {
int rewardResponseValue = MessageTypeProto.MessageType.TAKE_ACTIVITY_REWARD_RESPONSE_VALUE;
MessageUtil.sendErrorResponse(iSession, 0, rewardResponseValue, "no_such_activity_type");
return;
}
abstractActivity.takeReward(iSession, missionId);
}
}

View File

@ -0,0 +1,122 @@
package com.ljsd.jieling.logic.activity;
import com.ljsd.jieling.config.SActivityRewardConfig;
import com.ljsd.jieling.config.SGlobalActivity;
import com.ljsd.jieling.globals.BIReason;
import com.ljsd.jieling.ktbeans.KtEventUtils;
import com.ljsd.jieling.ktbeans.parmsBean.ParamEventBean;
import com.ljsd.jieling.logic.dao.ActivityManager;
import com.ljsd.jieling.logic.dao.ActivityMission;
import com.ljsd.jieling.logic.dao.ActivityProgressInfo;
import com.ljsd.jieling.logic.dao.UserManager;
import com.ljsd.jieling.logic.dao.root.User;
import com.ljsd.jieling.network.session.ISession;
import com.ljsd.jieling.protocols.CommonProto;
import com.ljsd.jieling.protocols.MessageTypeProto;
import com.ljsd.jieling.protocols.PlayerInfoProto;
import com.ljsd.jieling.util.ItemUtil;
import com.ljsd.jieling.util.MessageUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public abstract class AbstractActivity implements IActivity {
static final Logger LOGGER = LoggerFactory.getLogger(AbstractActivity.class);
final int rewardResponseValue = MessageTypeProto.MessageType.TAKE_ACTIVITY_REWARD_RESPONSE_VALUE;
int uid;
int type;
public AbstractActivity(int uid, int type) {
this.uid = uid;
this.type = type;
}
@Override
public void initActivity(User user) {
}
@Override
public void update(User user, int count, PlayerInfoProto.FivePlayerUpdateIndication.Builder fBuilder) {
ActivityMission activityMission = user.getActivityManager().getActivityMissionMap().get(type);
SGlobalActivity sGlobalActivity = SGlobalActivity.getsGlobalActivityMap().get(type);
updateProgress(activityMission, count);
if (fBuilder != null) {
long createTime = user.getPlayerInfoManager().getCreateTime();
int startTime = (int) (sGlobalActivity.getTimeLong(createTime, 1) / 1000);
int endTime = (int) (sGlobalActivity.getTimeLong(createTime, 2) / 1000);
Map<Integer, ActivityProgressInfo> activityProgressInfoMap = activityMission.getActivityProgressInfoMap();
List<CommonProto.ActivityInfo.MissionInfo> missionInfos = new ArrayList<>(activityProgressInfoMap.size());
for (Map.Entry<Integer, ActivityProgressInfo> missionProgress : activityProgressInfoMap.entrySet()) {
Integer missionId = missionProgress.getKey();
ActivityProgressInfo activityProgressInfo = missionProgress.getValue();
missionInfos.add(CommonProto.ActivityInfo.MissionInfo.newBuilder().setMissionId(missionId).setProgress(activityProgressInfo.getProgrss()).setState(activityProgressInfo.getState()).build());
}
fBuilder.addActivityInfo(CommonProto.ActivityInfo.newBuilder().setActivityId(type).addAllMission(missionInfos).setStartTime(startTime).setEndTime(endTime).setReallyOpen(activityMission.getOpenType()).build());
}
}
/**
* default update to progress
*/
void updateProgress(ActivityMission activityMission, int count) {
Map<Integer, ActivityProgressInfo> activityProgressInfoMap = activityMission.getActivityProgressInfoMap();
int progress;
for (Map.Entry<Integer, ActivityProgressInfo> item : activityProgressInfoMap.entrySet()) {
ActivityProgressInfo activityProgressInfo = item.getValue();
progress = item.getValue().getProgrss() + count;
activityProgressInfo.setProgrss(progress);
activityMission.updateProgressInfo(item.getKey(), activityProgressInfo);
}
}
@Override
public void takeReward(ISession session, int missionId) throws Exception {
User user = UserManager.getUser(uid);
SActivityRewardConfig sActivityRewardConfig = SActivityRewardConfig.getsActivityRewardConfigByMissionId(missionId);
if (sActivityRewardConfig == null || sActivityRewardConfig.getActivityId() != type) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "");
return;
}
ActivityManager activityManager = user.getActivityManager();
ActivityMission activityMission = activityManager.getActivityMissionMap().get(type);
if (activityMission == null || activityMission.getActivityState() != ActivityType.OPEN_STATE || activityMission.getOpenType() == 0) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "activity_close");
return;
}
ActivityProgressInfo activityProgressInfo = activityMission.getActivityProgressInfoMap().get(missionId);
if (activityProgressInfo == null || activityProgressInfo.getState() == ActivityType.HAD_TAKED) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "had taked");
return;
}
if (!takeRewardsProcess(session, sActivityRewardConfig, activityProgressInfo)) {
return;
}
int[][] reward = sActivityRewardConfig.getReward();
CommonProto.Drop.Builder drop = ItemUtil.drop(user, reward, BIReason.TAKE_ACTIVITY_REWARD);
activityProgressInfo.setState(ActivityType.HAD_TAKED);
activityMission.updateProgressInfo(missionId, activityProgressInfo);
KtEventUtils.onKtEvent(user, ParamEventBean.UserActivityEvent, type, missionId);
PlayerInfoProto.TakeActivityRewardResponse build = PlayerInfoProto.TakeActivityRewardResponse.newBuilder().setDrop(drop).build();
MessageUtil.sendMessage(session, 1, rewardResponseValue, build, true);
}
/**
* default get reward
*/
boolean takeRewardsProcess(ISession session, SActivityRewardConfig sActivityRewardConfig, ActivityProgressInfo activityProgressInfo) throws Exception {
int[][] values = sActivityRewardConfig.getValues();
int missionProgress = activityProgressInfo.getProgrss();
if (missionProgress < values[0][0]) {
LOGGER.error("the uid={} the misionId={},the missionProgress={},the require is={} ", uid, sActivityRewardConfig.getId(), missionProgress, values[0][0]);
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "time not");
return false;
}
return true;
}
}

View File

@ -146,22 +146,26 @@ public class ActivityLogic {
public void initOtherActivity(User user, SGlobalActivity sGlobalActivity) throws Exception {
int type = sGlobalActivity.getType();
switch (type){
switch (type) {
case ActivityType.TREASURE:
user.getUserMissionManager().onGameEvent(user,GameEvent.TREASH_REFRESH,sGlobalActivity.getId());
user.getUserMissionManager().onGameEvent(user, GameEvent.TREASH_REFRESH, sGlobalActivity.getId());
ActivityMission activityMission = new ActivityMission();
List<STreasureConfig> sTreasureConfigs = STreasureConfig.configByActivityIdMap.get(sGlobalActivity.getId());
List<Integer> misionIds = new ArrayList<>(sTreasureConfigs.size());
for(STreasureConfig sTreasureConfig : sTreasureConfigs){
for (STreasureConfig sTreasureConfig : sTreasureConfigs) {
misionIds.add(sTreasureConfig.getId());
}
activityMission.initOtherMission(misionIds);
long endTime = sGlobalActivity.getTimeLong(user.getPlayerInfoManager().getCreateTime(),2) -24*3600*1000;
long endTime = sGlobalActivity.getTimeLong(user.getPlayerInfoManager().getCreateTime(), 2) - 24 * 3600 * 1000;
user.getActivityManager().setTrsendTime(endTime);
user.getActivityManager().addActivity(sGlobalActivity.getId(),activityMission);
user.getActivityManager().addActivity(sGlobalActivity.getId(), activityMission);
break;
case ActivityType.BLESSACTIVITY:
blessInfoInit(user.getActivityManager(),sGlobalActivity.getId());
blessInfoInit(user.getActivityManager(), sGlobalActivity.getId());
break;
case ActivityType.LUCKYCAT:
ActivityTypeEnum.getActicityType(type,user.getId()).initActivity(user);
break;
case ActivityType.SERVERHAPPY:
initServenHappy(user,sGlobalActivity);
@ -181,203 +185,203 @@ public class ActivityLogic {
return ActivityLogic.Instance.instance;
}
public void takeTreasureReward(ISession session,User user,int activityId,int missionId) throws Exception {
int rewardResponseValue = MessageTypeProto.MessageType.TAKE_ACTIVITY_REWARD_RESPONSE_VALUE;
ActivityMission activityMission = user.getActivityManager().getActivityMissionMap().get(activityId);
PlayerManager playerInfoManager = user.getPlayerInfoManager();
int changeState =ActivityType.HAD_TAKED;
int hadBuyTreasure = playerInfoManager.getHadBuyTreasure();
if(hadBuyTreasure == 1){
changeState =ActivityType.FINISH_TAKED;
}
int treasureScore =playerInfoManager.getTreasureScore();
CommonProto.Drop.Builder drop = null;
if(missionId == -1){
List<int[][]> dropList = new ArrayList<>(10);
boolean canTakeFinalReward = true;
STreasureConfig finalSTreasureConfig = null;
Map<Integer,ActivityProgressInfo> willUpdateAcP = new HashMap<>();
for(Map.Entry<Integer,ActivityProgressInfo> activityProgressInfoItem: activityMission.getActivityProgressInfoMap().entrySet()){
Integer mineMision = activityProgressInfoItem.getKey();
STreasureConfig sTreasureConfig = STreasureConfig.configMap.get(mineMision);
if(sTreasureConfig.getType() == 2){
finalSTreasureConfig = sTreasureConfig;
continue;
}
ActivityProgressInfo value = activityProgressInfoItem.getValue();
int stateTmp = value.getState();
if(treasureScore>=sTreasureConfig.getPoints()){
if(changeState!=stateTmp){
STreasureConfig sTreasureConfigTmp = STreasureConfig.configMap.get(mineMision);
if(stateTmp == ActivityType.WILL_TAKE){
dropList.add(sTreasureConfigTmp.getReward());
}
if(changeState == ActivityType.FINISH_TAKED){
dropList.add(sTreasureConfigTmp.getTreasureReward());
}
willUpdateAcP.put(mineMision,value);
}
}else{
canTakeFinalReward = false;
}
}
for(Map.Entry<Integer,ActivityProgressInfo> item : willUpdateAcP.entrySet()){
ActivityProgressInfo value = item.getValue();
value.setState(changeState);
activityMission.updateProgressInfo(item.getKey(),value);
KtEventUtils.onKtEvent(user, ParamEventBean.UserActivityEvent,activityId,item.getKey());
}
if(canTakeFinalReward && finalSTreasureConfig!=null){
ActivityProgressInfo activityProgressInfo = activityMission.getActivityProgressInfoMap().get(finalSTreasureConfig.getId());
int stateTmp = activityProgressInfo.getState();
if(changeState!=stateTmp){
if(stateTmp == ActivityType.WILL_TAKE){
dropList.add(finalSTreasureConfig.getReward());
}
if(changeState == ActivityType.FINISH_TAKED){
dropList.add(finalSTreasureConfig.getTreasureReward());
}
activityProgressInfo.setState(changeState);
activityMission.updateProgressInfo(finalSTreasureConfig.getId(),activityProgressInfo);
KtEventUtils.onKtEvent(user, ParamEventBean.UserActivityEvent,activityId,finalSTreasureConfig.getId());
}
}
if(dropList.isEmpty()){
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"no one can take");
return;
}
drop = ItemUtil.drop(user, dropList, BIReason.TAKE_ACTIVITY_REWARD);
}else{
STreasureConfig sTreasureConfig = STreasureConfig.configMap.get(missionId);
int type = sTreasureConfig.getType();
ActivityProgressInfo activityProgressInfo = activityMission.getActivityProgressInfoMap().get(missionId);
int state = activityProgressInfo.getState();
if(state == changeState){
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"had taked");
return;
}
if(type == 1){
List<int[][]> dropList = new ArrayList<>(2);
if(treasureScore<sTreasureConfig.getPoints()){
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"not finish");
return;
}
if(state == ActivityType.WILL_TAKE){
dropList.add(sTreasureConfig.getReward());
}
if(changeState == ActivityType.FINISH_TAKED){
dropList.add(sTreasureConfig.getTreasureReward());
}
drop = ItemUtil.drop(user, dropList, BIReason.TAKE_ACTIVITY_REWARD);
activityProgressInfo.setState(changeState);
activityMission.updateProgressInfo(missionId,activityProgressInfo);
KtEventUtils.onKtEvent(user, ParamEventBean.UserActivityEvent,activityId,missionId);
}
}
PlayerInfoProto.TakeActivityRewardResponse build = PlayerInfoProto.TakeActivityRewardResponse.newBuilder().setDrop(drop).build();
MessageUtil.sendMessage(session,1,rewardResponseValue,build,true);
}
// public void takeTreasureReward(ISession session,User user,int activityId,int missionId) throws Exception {
// int rewardResponseValue = MessageTypeProto.MessageType.TAKE_ACTIVITY_REWARD_RESPONSE_VALUE;
// ActivityMission activityMission = user.getActivityManager().getActivityMissionMap().get(activityId);
// PlayerManager playerInfoManager = user.getPlayerInfoManager();
// int changeState =ActivityType.HAD_TAKED;
// int hadBuyTreasure = playerInfoManager.getHadBuyTreasure();
// if(hadBuyTreasure == 1){
// changeState =ActivityType.FINISH_TAKED;
// }
// int treasureScore =playerInfoManager.getTreasureScore();
// CommonProto.Drop.Builder drop = null;
// if(missionId == -1){
// List<int[][]> dropList = new ArrayList<>(10);
// boolean canTakeFinalReward = true;
// STreasureConfig finalSTreasureConfig = null;
// Map<Integer,ActivityProgressInfo> willUpdateAcP = new HashMap<>();
// for(Map.Entry<Integer,ActivityProgressInfo> activityProgressInfoItem: activityMission.getActivityProgressInfoMap().entrySet()){
// Integer mineMision = activityProgressInfoItem.getKey();
// STreasureConfig sTreasureConfig = STreasureConfig.configMap.get(mineMision);
// if(sTreasureConfig.getType() == 2){
// finalSTreasureConfig = sTreasureConfig;
// continue;
// }
// ActivityProgressInfo value = activityProgressInfoItem.getValue();
// int stateTmp = value.getState();
// if(changeState!=stateTmp && treasureScore>=sTreasureConfig.getPoints()){
// STreasureConfig sTreasureConfigTmp = STreasureConfig.configMap.get(mineMision);
// if(stateTmp == ActivityType.WILL_TAKE){
// dropList.add(sTreasureConfigTmp.getReward());
// }
// if(changeState == ActivityType.FINISH_TAKED){
// dropList.add(sTreasureConfigTmp.getTreasureReward());
// }
// willUpdateAcP.put(mineMision,value);
// }else{
// canTakeFinalReward = false;
// }
// }
// for(Map.Entry<Integer,ActivityProgressInfo> item : willUpdateAcP.entrySet()){
// ActivityProgressInfo value = item.getValue();
// value.setState(changeState);
// activityMission.updateProgressInfo(item.getKey(),value);
// KtEventUtils.onKtEvent(user, ParamEventBean.UserActivityEvent,activityId,item.getKey());
// }
// if(canTakeFinalReward && finalSTreasureConfig!=null){
// ActivityProgressInfo activityProgressInfo = activityMission.getActivityProgressInfoMap().get(finalSTreasureConfig.getId());
// int stateTmp = activityProgressInfo.getState();
// if(changeState!=stateTmp){
// if(stateTmp == ActivityType.WILL_TAKE){
// dropList.add(finalSTreasureConfig.getReward());
// }
// if(changeState == ActivityType.FINISH_TAKED){
// dropList.add(finalSTreasureConfig.getTreasureReward());
// }
// activityProgressInfo.setState(changeState);
// activityMission.updateProgressInfo(missionId,activityProgressInfo);
// KtEventUtils.onKtEvent(user, ParamEventBean.UserActivityEvent,activityId,finalSTreasureConfig.getId());
// }
// }
// if(dropList.isEmpty()){
// MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"no one can take");
// return;
// }
// drop = ItemUtil.drop(user, dropList, BIReason.TAKE_ACTIVITY_REWARD);
// }else{
// STreasureConfig sTreasureConfig = STreasureConfig.configMap.get(missionId);
// int type = sTreasureConfig.getType();
// ActivityProgressInfo activityProgressInfo = activityMission.getActivityProgressInfoMap().get(missionId);
// int state = activityProgressInfo.getState();
// if(state == changeState){
// MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"had taked");
// return;
// }
// if(type == 1){
// List<int[][]> dropList = new ArrayList<>(2);
// if(treasureScore<sTreasureConfig.getPoints()){
// MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"not finish");
// return;
// }
// if(state == ActivityType.WILL_TAKE){
// dropList.add(sTreasureConfig.getReward());
// }
// if(changeState == ActivityType.FINISH_TAKED){
// dropList.add(sTreasureConfig.getTreasureReward());
// }
// drop = ItemUtil.drop(user, dropList, BIReason.TAKE_ACTIVITY_REWARD);
// activityProgressInfo.setState(changeState);
// activityMission.updateProgressInfo(missionId,activityProgressInfo);
// KtEventUtils.onKtEvent(user, ParamEventBean.UserActivityEvent,activityId,missionId);
// }
// }
//
// PlayerInfoProto.TakeActivityRewardResponse build = PlayerInfoProto.TakeActivityRewardResponse.newBuilder().setDrop(drop).build();
// MessageUtil.sendMessage(session,1,rewardResponseValue,build,true);
// }
public void takeReward(ISession session,int activityId ,int missionId) throws Exception {
int uid = session.getUid();
User user = UserManager.getUser(uid);
int rewardResponseValue = MessageTypeProto.MessageType.TAKE_ACTIVITY_REWARD_RESPONSE_VALUE;
SGlobalActivity sGlobalActivity = SGlobalActivity.getsGlobalActivityMap().get(activityId);
if(sGlobalActivity == null || !user.getActivityManager().getActivityMissionMap().containsKey(activityId)){
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"");
return;
}
if(sGlobalActivity.getType() == ActivityType.TREASURE){
takeTreasureReward(session,user,activityId,missionId);
return;
}
SActivityRewardConfig sActivityRewardConfig = SActivityRewardConfig.getsActivityRewardConfigByMissionId(missionId);
if(sActivityRewardConfig == null || sActivityRewardConfig.getActivityId()!=activityId){
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"");
return;
}
ActivityManager activityManager = user.getActivityManager();
ActivityMission activityMission = activityManager.getActivityMissionMap().get(activityId);
if(activityMission == null || activityMission.getActivityState()!=ActivityType.OPEN_STATE || activityMission.getOpenType() == 0){
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"activity_close");
return;
}
ActivityProgressInfo activityProgressInfo = activityMission.getActivityProgressInfoMap().get(missionId);
if( activityProgressInfo ==null || activityProgressInfo.getState() == ActivityType.HAD_TAKED){
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"had taked");
return;
}
int[][] values = sActivityRewardConfig.getValues();
int missionProgress = activityProgressInfo.getProgrss();
switch (sGlobalActivity.getType()){
case ActivityType.ChapterReward:{
LevelDifficulty levelDifficulty = user.getLevelDifficultyManager().getLevelDifficultyInfosMap().get(values[0][0]);
if(levelDifficulty == null || levelDifficulty.getState()!= Global.FIGHT_CLEARANCE){
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"not pass");
return;
}
}
break;
case ActivityType.OnlineReward:{
long now = TimeUtils.now();
PlayerManager playerInfoManager = user.getPlayerInfoManager();
long loginTime = playerInfoManager.getLoginTime();
int limitTime = values[0][0];
long remainTime = now - loginTime - limitTime * TimeUtils.ONE_MINUTE + missionProgress * TimeUtils.ONE_SECOND;
if(now - loginTime - limitTime * TimeUtils.ONE_MINUTE + missionProgress * TimeUtils.ONE_SECOND<0){
LOGGER.error("the uid={} remain time is={}ms,the require time is={}ms",uid,remainTime,limitTime * TimeUtils.ONE_MINUTE);
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"time not");
return;
}
}
break;
case ActivityType.RechargeTotal:{
long now = TimeUtils.now();
RechargeInfo rechargeInfo = user.getPlayerInfoManager().getRechargeInfo();
int days = TimeUtils.differentDays(rechargeInfo.getCreateTime(), now)+1;
if(missionProgress<values[0][0] || days<values[0][1]){
LOGGER.error("the uid={} the misionId={},the missionProgress={},the require is={} ",uid,missionId,missionProgress,values[0][0]);
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"not finish");
return;
}
}
break;
case ActivityType.GrowthFund:{
int type = values[0][0];
int value = values[0][1];
if(type == 9){
int level = user.getPlayerInfoManager().getLevel();
if(level<value){
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"not finish");
return;
}
}else if(type == 15){
LevelDifficulty levelDifficulty = user.getLevelDifficultyManager().getLevelDifficultyInfosMap().get(value);
if(levelDifficulty == null || levelDifficulty.getState()!= Global.FIGHT_CLEARANCE){
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"not finish");
return;
}
}
}
break;
default:
if(missionProgress<values[0][0]){
LOGGER.error("the uid={} the misionId={},the missionProgress={},the require is={} ",uid,missionId,missionProgress,values[0][0]);
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"time not");
return;
}
break;
}
int[][] reward = sActivityRewardConfig.getReward();
CommonProto.Drop.Builder drop = ItemUtil.drop(user, reward, BIReason.TAKE_ACTIVITY_REWARD);
activityProgressInfo.setState(ActivityType.HAD_TAKED);
activityMission.updateProgressInfo(missionId,activityProgressInfo);
KtEventUtils.onKtEvent(user, ParamEventBean.UserActivityEvent,activityId,missionId);
PlayerInfoProto.TakeActivityRewardResponse build = PlayerInfoProto.TakeActivityRewardResponse.newBuilder().setDrop(drop).build();
MessageUtil.sendMessage(session,1,rewardResponseValue,build,true);
}
// public void takeReward(ISession session,int activityId ,int missionId) throws Exception {
// int uid = session.getUid();
// User user = UserManager.getUser(uid);
// int rewardResponseValue = MessageTypeProto.MessageType.TAKE_ACTIVITY_REWARD_RESPONSE_VALUE;
// SGlobalActivity sGlobalActivity = SGlobalActivity.getsGlobalActivityMap().get(activityId);
// if(sGlobalActivity == null || !user.getActivityManager().getActivityMissionMap().containsKey(activityId)){
// MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"");
// return;
// }
// if(sGlobalActivity.getType() == ActivityType.TREASURE){
// takeTreasureReward(session,user,activityId,missionId);
// return;
// }
// SActivityRewardConfig sActivityRewardConfig = SActivityRewardConfig.getsActivityRewardConfigByMissionId(missionId);
// if(sActivityRewardConfig == null || sActivityRewardConfig.getActivityId()!=activityId){
// MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"");
// return;
// }
// ActivityManager activityManager = user.getActivityManager();
// ActivityMission activityMission = activityManager.getActivityMissionMap().get(activityId);
// if(activityMission == null || activityMission.getActivityState()!=ActivityType.OPEN_STATE || activityMission.getOpenType() == 0){
// MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"activity_close");
// return;
// }
// ActivityProgressInfo activityProgressInfo = activityMission.getActivityProgressInfoMap().get(missionId);
// if( activityProgressInfo ==null || activityProgressInfo.getState() == ActivityType.HAD_TAKED){
// MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"had taked");
// return;
// }
// int[][] values = sActivityRewardConfig.getValues();
// int missionProgress = activityProgressInfo.getProgrss();
// switch (sGlobalActivity.getType()){
// case ActivityType.ChapterReward:{
// LevelDifficulty levelDifficulty = user.getLevelDifficultyManager().getLevelDifficultyInfosMap().get(values[0][0]);
// if(levelDifficulty == null || levelDifficulty.getState()!= Global.FIGHT_CLEARANCE){
// MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"not pass");
// return;
// }
// }
// break;
// case ActivityType.OnlineReward:{
// long now = TimeUtils.now();
// PlayerManager playerInfoManager = user.getPlayerInfoManager();
// long loginTime = playerInfoManager.getLoginTime();
// int limitTime = values[0][0];
// long remainTime = now - loginTime - limitTime * TimeUtils.ONE_MINUTE + missionProgress * TimeUtils.ONE_SECOND;
// if(now - loginTime - limitTime * TimeUtils.ONE_MINUTE + missionProgress * TimeUtils.ONE_SECOND<0){
// LOGGER.error("the uid={} remain time is={}ms,the require time is={}ms",uid,remainTime,limitTime * TimeUtils.ONE_MINUTE);
// MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"time not");
// return;
// }
// }
// break;
// case ActivityType.RechargeTotal:{
// long now = TimeUtils.now();
// RechargeInfo rechargeInfo = user.getPlayerInfoManager().getRechargeInfo();
// int days = TimeUtils.differentDays(rechargeInfo.getCreateTime(), now)+1;
// if(missionProgress<values[0][0] || days<values[0][1]){
// LOGGER.error("the uid={} the misionId={},the missionProgress={},the require is={} ",uid,missionId,missionProgress,values[0][0]);
// MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"not finish");
// return;
// }
// }
// break;
// case ActivityType.GrowthFund:{
// int type = values[0][0];
// int value = values[0][1];
// if(type == 9){
// int level = user.getPlayerInfoManager().getLevel();
// if(level<value){
// MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"not finish");
// return;
// }
// }else if(type == 15){
// LevelDifficulty levelDifficulty = user.getLevelDifficultyManager().getLevelDifficultyInfosMap().get(value);
// if(levelDifficulty == null || levelDifficulty.getState()!= Global.FIGHT_CLEARANCE){
// MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"not finish");
// return;
// }
//
// }
// }
// break;
// default:
// if(missionProgress<values[0][0]){
// LOGGER.error("the uid={} the misionId={},the missionProgress={},the require is={} ",uid,missionId,missionProgress,values[0][0]);
// MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"time not");
// return;
// }
// break;
// }
// int[][] reward = sActivityRewardConfig.getReward();
// CommonProto.Drop.Builder drop = ItemUtil.drop(user, reward, BIReason.TAKE_ACTIVITY_REWARD);
// activityProgressInfo.setState(ActivityType.HAD_TAKED);
// activityMission.updateProgressInfo(missionId,activityProgressInfo);
// KtEventUtils.onKtEvent(user, ParamEventBean.UserActivityEvent,activityId,missionId);
// PlayerInfoProto.TakeActivityRewardResponse build = PlayerInfoProto.TakeActivityRewardResponse.newBuilder().setDrop(drop).build();
// MessageUtil.sendMessage(session,1,rewardResponseValue,build,true);
// }
public void getAllActivityInfo(ISession session) throws Exception {
int uid = session.getUid();
@ -435,50 +439,52 @@ public class ActivityLogic {
}
public void updateActivityMissionProgress(User user,int activityType,int count, PlayerInfoProto.FivePlayerUpdateIndication.Builder fBuilder){
ActivityManager activityManager = user.getActivityManager();
Map<Integer, ActivityMission> activityMissionMap = activityManager.getActivityMissionMap();
for(Map.Entry<Integer,ActivityMission> item : activityMissionMap.entrySet()){
ActivityMission activityMission = item.getValue();
if(activityMission.getActivityState() != ActivityType.OPEN_STATE){
continue;
}
Integer activityId= item.getKey();
SGlobalActivity sGlobalActivity = SGlobalActivity.getsGlobalActivityMap().get(activityId);
int targetActivityType = sGlobalActivity.getType();
if(targetActivityType != activityType){
continue;
}
updateProgress(activityType,activityMissionMap.get(activityId),count);
if(fBuilder!=null){
long createTime = user.getPlayerInfoManager().getCreateTime();
int startTime = (int)(sGlobalActivity.getTimeLong(createTime, 1)/1000);
int endTime = (int)(sGlobalActivity.getTimeLong(createTime, 2)/1000);
Map<Integer, ActivityProgressInfo> activityProgressInfoMap = activityMission.getActivityProgressInfoMap();
List<CommonProto.ActivityInfo.MissionInfo> missionInfos = new ArrayList<>(activityProgressInfoMap.size());
for( Map.Entry<Integer, ActivityProgressInfo> missionProgress : activityProgressInfoMap.entrySet()){
Integer missionId = missionProgress.getKey();
ActivityProgressInfo activityProgressInfo = missionProgress.getValue();
missionInfos.add(CommonProto.ActivityInfo.MissionInfo.newBuilder().setMissionId(missionId).setProgress(activityProgressInfo.getProgrss()).setState(activityProgressInfo.getState()).build());
}
fBuilder.addActivityInfo(CommonProto.ActivityInfo.newBuilder().setActivityId(activityId).addAllMission(missionInfos).setStartTime(startTime).setEndTime(endTime).setReallyOpen(activityMission.getOpenType()).build());
}
}
}
private void updateProgress(int activityType,ActivityMission activityMission,int count){
Map<Integer, ActivityProgressInfo> activityProgressInfoMap = activityMission.getActivityProgressInfoMap();
int progress;
switch (activityType){
default:
for (Map.Entry<Integer, ActivityProgressInfo> item : activityProgressInfoMap.entrySet()) {
ActivityProgressInfo activityProgressInfo = item.getValue();
progress = item.getValue().getProgrss() + count;
activityProgressInfo.setProgrss(progress);
activityMission.updateProgressInfo(item.getKey(), activityProgressInfo);
}
break;
}
ActivityTypeEnum.getActicityType(activityType,user.getId()).update(user,count,fBuilder);
// ActivityManager activityManager = user.getActivityManager();
// Map<Integer, ActivityMission> activityMissionMap = activityManager.getActivityMissionMap();
// for(Map.Entry<Integer,ActivityMission> item : activityMissionMap.entrySet()){
// ActivityMission activityMission = item.getValue();
// if(activityMission.getActivityState() != ActivityType.OPEN_STATE){
// continue;
// }
// Integer activityId= item.getKey();
// SGlobalActivity sGlobalActivity = SGlobalActivity.getsGlobalActivityMap().get(activityId);
// int targetActivityType = sGlobalActivity.getType();
// if(targetActivityType != activityType){
// continue;
// }
// updateProgress(activityType,activityMissionMap.get(activityId),count);
// if(fBuilder!=null){
// long createTime = user.getPlayerInfoManager().getCreateTime();
// int startTime = (int)(sGlobalActivity.getTimeLong(createTime, 1)/1000);
// int endTime = (int)(sGlobalActivity.getTimeLong(createTime, 2)/1000);
// Map<Integer, ActivityProgressInfo> activityProgressInfoMap = activityMission.getActivityProgressInfoMap();
// List<CommonProto.ActivityInfo.MissionInfo> missionInfos = new ArrayList<>(activityProgressInfoMap.size());
// for( Map.Entry<Integer, ActivityProgressInfo> missionProgress : activityProgressInfoMap.entrySet()){
// Integer missionId = missionProgress.getKey();
// ActivityProgressInfo activityProgressInfo = missionProgress.getValue();
// missionInfos.add(CommonProto.ActivityInfo.MissionInfo.newBuilder().setMissionId(missionId).setProgress(activityProgressInfo.getProgrss()).setState(activityProgressInfo.getState()).build());
// }
// fBuilder.addActivityInfo(CommonProto.ActivityInfo.newBuilder().setActivityId(activityId).addAllMission(missionInfos).setStartTime(startTime).setEndTime(endTime).setReallyOpen(activityMission.getOpenType()).build());
// }
// }
}
//
// private void updateProgress(int activityType,ActivityMission activityMission,int count){
// Map<Integer, ActivityProgressInfo> activityProgressInfoMap = activityMission.getActivityProgressInfoMap();
// int progress;
// switch (activityType){
// default:
// for (Map.Entry<Integer, ActivityProgressInfo> item : activityProgressInfoMap.entrySet()) {
// ActivityProgressInfo activityProgressInfo = item.getValue();
// progress = item.getValue().getProgrss() + count;
// activityProgressInfo.setProgrss(progress);
// activityMission.updateProgressInfo(item.getKey(), activityProgressInfo);
// }
// break;
// }
// }
public void checkActivityIsFinish(User user){
ActivityManager activityManager = user.getActivityManager();

View File

@ -24,6 +24,7 @@ public interface ActivityType {
int GrowthFund =6; //成长基金
int BLESSACTIVITY = 7;
int TREASURE =8; //孙龙的宝藏
int LUCKYCAT=9;//招財貓
int SERVERHAPPY =10; //七日狂欢
}

View File

@ -0,0 +1,56 @@
package com.ljsd.jieling.logic.activity;
import java.util.function.BiFunction;
public enum ActivityTypeEnum {
ONLINEREWARD(ActivityType.OnlineReward, OnlineRewardActivity::new),
SEVENLOGIN(ActivityType.SevenLogin, SevenLoginActivity::new),
CHAPTERREWARD(ActivityType.ChapterReward, ChapterRewardActivity::new),
FIRSTRECHARGE(ActivityType.FirstRecharge, FirstRechargeActivity::new),
RECHARGETOTAL(ActivityType.RechargeTotal, RechargeTotalActivity::new),
GROWTHFUND(ActivityType.GrowthFund, GrowthFundActivity::new),
BLESSACTIVITY(ActivityType.BLESSACTIVITY, TreasureActivity::new),
TREASUREACTIVITY(ActivityType.TREASURE, TreasureActivity::new),
LUCKYCAT(ActivityType.LUCKYCAT, LuckyCatActivity::new);
private int type;
private BiFunction<Integer, Integer, AbstractActivity> toActivityFunction;
ActivityTypeEnum(int type, BiFunction<Integer, Integer, AbstractActivity> toActivityFunction) {
this.type = type;
this.toActivityFunction = toActivityFunction;
}
public AbstractActivity toActivity(int uid) {
return toActivityFunction.apply(uid, getType());
}
public static AbstractActivity getActicityType(int activityType, int uid) {
switch (activityType) {
case ActivityType.OnlineReward:
return ONLINEREWARD.toActivity(uid);
case ActivityType.SevenLogin:
return SEVENLOGIN.toActivity(uid);
case ActivityType.ChapterReward:
return CHAPTERREWARD.toActivity(uid);
case ActivityType.FirstRecharge:
return FIRSTRECHARGE.toActivity(uid);
case ActivityType.RechargeTotal:
return RECHARGETOTAL.toActivity(uid);
case ActivityType.GrowthFund:
return GROWTHFUND.toActivity(uid);
case ActivityType.BLESSACTIVITY:
return BLESSACTIVITY.toActivity(uid);
case ActivityType.TREASURE:
return TREASUREACTIVITY.toActivity(uid);
case ActivityType.LUCKYCAT:
return LUCKYCAT.toActivity(uid);
default:
return null;
}
}
public int getType() {
return type;
}
}

View File

@ -0,0 +1,10 @@
package com.ljsd.jieling.logic.activity;
public class BlessActivity extends AbstractActivity {
public BlessActivity(int uid, int type) {
super(uid, type);
}
}

View File

@ -0,0 +1,29 @@
package com.ljsd.jieling.logic.activity;
import com.ljsd.jieling.config.SActivityRewardConfig;
import com.ljsd.jieling.globals.Global;
import com.ljsd.jieling.logic.dao.ActivityProgressInfo;
import com.ljsd.jieling.logic.dao.LevelDifficulty;
import com.ljsd.jieling.logic.dao.UserManager;
import com.ljsd.jieling.logic.dao.root.User;
import com.ljsd.jieling.network.session.ISession;
import com.ljsd.jieling.util.MessageUtil;
class ChapterRewardActivity extends AbstractActivity {
ChapterRewardActivity(int uid, int type) {
super(uid, type);
}
@Override
boolean takeRewardsProcess(ISession session, SActivityRewardConfig sActivityRewardConfig, ActivityProgressInfo activityProgressInfo) throws Exception {
int[][] values = sActivityRewardConfig.getValues();
User user = UserManager.getUser(uid);
LevelDifficulty levelDifficulty = user.getLevelDifficultyManager().getLevelDifficultyInfosMap().get(values[0][0]);
if (levelDifficulty == null || levelDifficulty.getState() != Global.FIGHT_CLEARANCE) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "not pass");
return false;
}
return true;
}
}

View File

@ -0,0 +1,10 @@
package com.ljsd.jieling.logic.activity;
public class FirstRechargeActivity extends AbstractActivity {
FirstRechargeActivity(int uid, int type) {
super(uid, type);
}
}

View File

@ -0,0 +1,39 @@
package com.ljsd.jieling.logic.activity;
import com.ljsd.jieling.config.SActivityRewardConfig;
import com.ljsd.jieling.globals.Global;
import com.ljsd.jieling.logic.dao.ActivityProgressInfo;
import com.ljsd.jieling.logic.dao.LevelDifficulty;
import com.ljsd.jieling.logic.dao.UserManager;
import com.ljsd.jieling.logic.dao.root.User;
import com.ljsd.jieling.network.session.ISession;
import com.ljsd.jieling.util.MessageUtil;
class GrowthFundActivity extends AbstractActivity {
GrowthFundActivity(int uid, int type) {
super(uid, type);
}
@Override
boolean takeRewardsProcess(ISession session, SActivityRewardConfig sActivityRewardConfig, ActivityProgressInfo activityProgressInfo) throws Exception {
int[][] values = sActivityRewardConfig.getValues();
User user = UserManager.getUser(uid);
int type = values[0][0];
int value = values[0][1];
if(type == 9){
int level = user.getPlayerInfoManager().getLevel();
if(level<value){
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"not finish");
return false;
}
}else if(type == 15){
LevelDifficulty levelDifficulty = user.getLevelDifficultyManager().getLevelDifficultyInfosMap().get(value);
if(levelDifficulty == null || levelDifficulty.getState()!= Global.FIGHT_CLEARANCE){
MessageUtil.sendErrorResponse(session,0,rewardResponseValue,"not finish");
return false;
}
}
return true;
}
}

View File

@ -0,0 +1,27 @@
package com.ljsd.jieling.logic.activity;
import com.ljsd.jieling.logic.dao.root.User;
import com.ljsd.jieling.network.session.ISession;
import com.ljsd.jieling.protocols.PlayerInfoProto;
public interface IActivity {
/**
*
* @param user
* Todo
*/
void initActivity(User user);
/**
*
*/
void update(User user, int count, PlayerInfoProto.FivePlayerUpdateIndication.Builder fBuilder);
/**
*
* @param missionId id
*/
void takeReward(ISession session, int missionId) throws Exception;
}

View File

@ -0,0 +1,128 @@
package com.ljsd.jieling.logic.activity;
import com.ljsd.jieling.config.SGlobalActivity;
import com.ljsd.jieling.config.SLuckyCatConfig;
import com.ljsd.jieling.globals.BIReason;
import com.ljsd.jieling.ktbeans.KtEventUtils;
import com.ljsd.jieling.ktbeans.parmsBean.ParamEventBean;
import com.ljsd.jieling.logic.dao.ActivityMission;
import com.ljsd.jieling.logic.dao.ActivityProgressInfo;
import com.ljsd.jieling.logic.dao.UserManager;
import com.ljsd.jieling.logic.dao.root.User;
import com.ljsd.jieling.network.session.ISession;
import com.ljsd.jieling.protocols.CommonProto;
import com.ljsd.jieling.protocols.PlayerInfoProto;
import com.ljsd.jieling.util.ItemUtil;
import com.ljsd.jieling.util.MathUtils;
import com.ljsd.jieling.util.MessageUtil;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class LuckyCatActivity extends AbstractActivity {
LuckyCatActivity(int uid, int type) {
super(uid, type);
}
@Override
public void initActivity(User user) {
ActivityMission mission = new ActivityMission();
List<Integer> luckyMisionIds = new ArrayList<>();
SLuckyCatConfig.configMap.values().forEach(sLuckyCatConfig ->
luckyMisionIds.add(sLuckyCatConfig.getId())
);
mission.initOtherMission(luckyMisionIds);
user.getActivityManager().addActivity(type, mission);
}
@Override
void updateProgress(ActivityMission activityMission, int count) {
activityMission.setValue(count);
}
@Override
public void takeReward(ISession session, int missionId) throws Exception {
User user = UserManager.getUser(uid);
SGlobalActivity sGlobalActivity = SGlobalActivity.getsGlobalActivityMap().get(type);
if (sGlobalActivity == null || !user.getActivityManager().getActivityMissionMap().containsKey(type)) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "");
return;
}
takeLuckCatReward(session, user, missionId);
}
private void takeLuckCatReward(ISession session, User user, int missionId) throws Exception {
ActivityMission activityMission = user.getActivityManager().getActivityMissionMap().get(type);
//check activity
if (activityMission == null || activityMission.getActivityState() != ActivityType.OPEN_STATE || activityMission.getOpenType() == 0) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "activity_close");
return;
}
if (missionId != checkCurrencyMissionId(activityMission))
return;
ActivityProgressInfo activityProgressInfo = activityMission.getActivityProgressInfoMap().get(missionId);
if (activityProgressInfo == null || activityProgressInfo.getState() == ActivityType.HAD_TAKED) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "had taked");
return;
}
//check cfg
SLuckyCatConfig sLuckyRewardConfig = SLuckyCatConfig.configMap.get(missionId);
if (sLuckyRewardConfig == null || sLuckyRewardConfig.getActivityId() != type) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "config null");
}
if (activityMission.getValue() < sLuckyRewardConfig.getRmbValue())
return;
if (activityProgressInfo.getProgrss() >= SLuckyCatConfig.getMiss2time(missionId)) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "had taked");
return;
}
//check cost
int[][] cost = new int[1][];
int[] temp = new int[2];
temp[0] = sLuckyRewardConfig.getLuckyType();
temp[1] = sLuckyRewardConfig.getConsumeValue();
cost[0] = temp;
boolean enough = ItemUtil.itemCost(user, cost, BIReason.LUCKYCAT_CONSUME, 1);
if (!enough) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "道具不足");
return;
}
activityProgressInfo.setProgrss(activityProgressInfo.getProgrss() + 1);
if (activityProgressInfo.getProgrss() >= SLuckyCatConfig.getMiss2time(missionId)) {
activityProgressInfo.setState(ActivityType.HAD_TAKED);
}
//drop
int[][] reward = new int[1][];
int[] temp2 = new int[2];
temp2[0] = sLuckyRewardConfig.getLuckyType();
temp2[1] = MathUtils.random(sLuckyRewardConfig.getValueDown(), sLuckyRewardConfig.getValueUp());
reward[0] = temp2;
activityMission.updateProgressInfo(missionId, activityProgressInfo);
CommonProto.Drop.Builder drop = ItemUtil.drop(user, reward, BIReason.TAKE_ACTIVITY_REWARD);
KtEventUtils.onKtEvent(user, ParamEventBean.UserActivityEvent, type, missionId);
PlayerInfoProto.LuckCatRewardResponse build = PlayerInfoProto.LuckCatRewardResponse.newBuilder().setDrop(drop).setMissionId(missionId).build();
MessageUtil.sendMessage(session, 1, rewardResponseValue, build, true);
}
private int checkCurrencyMissionId(ActivityMission activityMission) {
Map<Integer, ActivityProgressInfo> sortMap = new TreeMap<>(activityMission.getActivityProgressInfoMap());
for (Map.Entry<Integer, ActivityProgressInfo> item : sortMap.entrySet()) {
ActivityProgressInfo activityProgressInfo = item.getValue();
if (activityProgressInfo.getState() == ActivityType.HAD_TAKED) {
continue;
}
return item.getKey();
}
return 0;
}
}

View File

@ -0,0 +1,36 @@
package com.ljsd.jieling.logic.activity;
import com.ljsd.jieling.config.SActivityRewardConfig;
import com.ljsd.jieling.logic.dao.ActivityProgressInfo;
import com.ljsd.jieling.logic.dao.PlayerManager;
import com.ljsd.jieling.logic.dao.UserManager;
import com.ljsd.jieling.logic.dao.root.User;
import com.ljsd.jieling.network.session.ISession;
import com.ljsd.jieling.util.MessageUtil;
import com.ljsd.jieling.util.TimeUtils;
class OnlineRewardActivity extends AbstractActivity {
OnlineRewardActivity(int uid, int type) {
super(uid, type);
}
@Override
boolean takeRewardsProcess(ISession session, SActivityRewardConfig sActivityRewardConfig, ActivityProgressInfo activityProgressInfo) throws Exception {
int[][] values = sActivityRewardConfig.getValues();
int missionProgress = activityProgressInfo.getProgrss();
long now = TimeUtils.now();
User user = UserManager.getUser(uid);
PlayerManager playerInfoManager = user.getPlayerInfoManager();
long loginTime = playerInfoManager.getLoginTime();
int limitTime = values[0][0];
long remainTime = now - loginTime - limitTime * TimeUtils.ONE_MINUTE + missionProgress * TimeUtils.ONE_SECOND;
if (now - loginTime - limitTime * TimeUtils.ONE_MINUTE + missionProgress * TimeUtils.ONE_SECOND < 0) {
LOGGER.error("the uid={} remain time is={}ms,the require time is={}ms", uid, remainTime, limitTime * TimeUtils.ONE_MINUTE);
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "time not");
return false;
}
return true;
}
}

View File

@ -0,0 +1,33 @@
package com.ljsd.jieling.logic.activity;
import com.ljsd.jieling.config.SActivityRewardConfig;
import com.ljsd.jieling.logic.dao.ActivityProgressInfo;
import com.ljsd.jieling.logic.dao.RechargeInfo;
import com.ljsd.jieling.logic.dao.UserManager;
import com.ljsd.jieling.logic.dao.root.User;
import com.ljsd.jieling.network.session.ISession;
import com.ljsd.jieling.util.MessageUtil;
import com.ljsd.jieling.util.TimeUtils;
class RechargeTotalActivity extends AbstractActivity {
RechargeTotalActivity(int uid, int type) {
super(uid, type);
}
@Override
boolean takeRewardsProcess(ISession session, SActivityRewardConfig sActivityRewardConfig, ActivityProgressInfo activityProgressInfo) throws Exception {
int[][] values = sActivityRewardConfig.getValues();
int missionProgress = activityProgressInfo.getProgrss();
long now = TimeUtils.now();
User user = UserManager.getUser(uid);
RechargeInfo rechargeInfo = user.getPlayerInfoManager().getRechargeInfo();
int days = TimeUtils.differentDays(rechargeInfo.getCreateTime(), now) + 1;
if (missionProgress < values[0][0] || days < values[0][1]) {
LOGGER.error("the uid={} the misionId={},the missionProgress={},the require is={} ", uid, sActivityRewardConfig.getId(), missionProgress, values[0][0]);
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "not finish");
return false;
}
return true;
}
}

View File

@ -0,0 +1,10 @@
package com.ljsd.jieling.logic.activity;
class SevenLoginActivity extends AbstractActivity {
SevenLoginActivity(int uid, int type) {
super(uid, type);
}
}

View File

@ -0,0 +1,141 @@
package com.ljsd.jieling.logic.activity;
import com.ljsd.jieling.config.SGlobalActivity;
import com.ljsd.jieling.config.STreasureConfig;
import com.ljsd.jieling.globals.BIReason;
import com.ljsd.jieling.ktbeans.KtEventUtils;
import com.ljsd.jieling.ktbeans.parmsBean.ParamEventBean;
import com.ljsd.jieling.logic.dao.ActivityMission;
import com.ljsd.jieling.logic.dao.ActivityProgressInfo;
import com.ljsd.jieling.logic.dao.PlayerManager;
import com.ljsd.jieling.logic.dao.UserManager;
import com.ljsd.jieling.logic.dao.root.User;
import com.ljsd.jieling.network.session.ISession;
import com.ljsd.jieling.protocols.CommonProto;
import com.ljsd.jieling.protocols.MessageTypeProto;
import com.ljsd.jieling.protocols.PlayerInfoProto;
import com.ljsd.jieling.util.ItemUtil;
import com.ljsd.jieling.util.MessageUtil;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class TreasureActivity extends AbstractActivity {
TreasureActivity(int uid, int type) {
super(uid, type);
}
@Override
public void takeReward(ISession session, int missionId) throws Exception {
User user = UserManager.getUser(uid);
SGlobalActivity sGlobalActivity = SGlobalActivity.getsGlobalActivityMap().get(type);
if (sGlobalActivity == null || !user.getActivityManager().getActivityMissionMap().containsKey(type)) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "");
return;
}
takeTreasureReward(session, user, type, missionId);
}
private void takeTreasureReward(ISession session, User user, int activityId, int missionId) throws Exception {
int rewardResponseValue = MessageTypeProto.MessageType.TAKE_ACTIVITY_REWARD_RESPONSE_VALUE;
ActivityMission activityMission = user.getActivityManager().getActivityMissionMap().get(activityId);
PlayerManager playerInfoManager = user.getPlayerInfoManager();
int changeState = ActivityType.HAD_TAKED;
int hadBuyTreasure = playerInfoManager.getHadBuyTreasure();
if (hadBuyTreasure == 1) {
changeState = ActivityType.FINISH_TAKED;
}
int treasureScore = playerInfoManager.getTreasureScore();
CommonProto.Drop.Builder drop = null;
if (missionId == -1) {
List<int[][]> dropList = new ArrayList<>(10);
boolean canTakeFinalReward = true;
STreasureConfig finalSTreasureConfig = null;
Map<Integer, ActivityProgressInfo> willUpdateAcP = new HashMap<>();
for (Map.Entry<Integer, ActivityProgressInfo> activityProgressInfoItem : activityMission.getActivityProgressInfoMap().entrySet()) {
Integer mineMision = activityProgressInfoItem.getKey();
STreasureConfig sTreasureConfig = STreasureConfig.configMap.get(mineMision);
if (sTreasureConfig.getType() == 2) {
finalSTreasureConfig = sTreasureConfig;
continue;
}
ActivityProgressInfo value = activityProgressInfoItem.getValue();
int stateTmp = value.getState();
if (treasureScore >= sTreasureConfig.getPoints()) {
if (changeState != stateTmp) {
STreasureConfig sTreasureConfigTmp = STreasureConfig.configMap.get(mineMision);
if (stateTmp == ActivityType.WILL_TAKE) {
dropList.add(sTreasureConfigTmp.getReward());
}
if (changeState == ActivityType.FINISH_TAKED) {
dropList.add(sTreasureConfigTmp.getTreasureReward());
}
willUpdateAcP.put(mineMision, value);
}
} else {
canTakeFinalReward = false;
}
}
for (Map.Entry<Integer, ActivityProgressInfo> item : willUpdateAcP.entrySet()) {
ActivityProgressInfo value = item.getValue();
value.setState(changeState);
activityMission.updateProgressInfo(item.getKey(), value);
KtEventUtils.onKtEvent(user, ParamEventBean.UserActivityEvent, activityId, item.getKey());
}
if (canTakeFinalReward && finalSTreasureConfig != null) {
ActivityProgressInfo activityProgressInfo = activityMission.getActivityProgressInfoMap().get(finalSTreasureConfig.getId());
int stateTmp = activityProgressInfo.getState();
if (changeState != stateTmp) {
if (stateTmp == ActivityType.WILL_TAKE) {
dropList.add(finalSTreasureConfig.getReward());
}
if (changeState == ActivityType.FINISH_TAKED) {
dropList.add(finalSTreasureConfig.getTreasureReward());
}
activityProgressInfo.setState(changeState);
activityMission.updateProgressInfo(finalSTreasureConfig.getId(), activityProgressInfo);
KtEventUtils.onKtEvent(user, ParamEventBean.UserActivityEvent, activityId, finalSTreasureConfig.getId());
}
}
if (dropList.isEmpty()) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "no one can take");
return;
}
drop = ItemUtil.drop(user, dropList, BIReason.TAKE_ACTIVITY_REWARD);
} else {
STreasureConfig sTreasureConfig = STreasureConfig.configMap.get(missionId);
int type = sTreasureConfig.getType();
ActivityProgressInfo activityProgressInfo = activityMission.getActivityProgressInfoMap().get(missionId);
int state = activityProgressInfo.getState();
if (state == changeState) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "had taked");
return;
}
if (type == 1) {
List<int[][]> dropList = new ArrayList<>(2);
if (treasureScore < sTreasureConfig.getPoints()) {
MessageUtil.sendErrorResponse(session, 0, rewardResponseValue, "not finish");
return;
}
if (state == ActivityType.WILL_TAKE) {
dropList.add(sTreasureConfig.getReward());
}
if (changeState == ActivityType.FINISH_TAKED) {
dropList.add(sTreasureConfig.getTreasureReward());
}
drop = ItemUtil.drop(user, dropList, BIReason.TAKE_ACTIVITY_REWARD);
activityProgressInfo.setState(changeState);
activityMission.updateProgressInfo(missionId, activityProgressInfo);
KtEventUtils.onKtEvent(user, ParamEventBean.UserActivityEvent, activityId, missionId);
}
}
PlayerInfoProto.TakeActivityRewardResponse build = PlayerInfoProto.TakeActivityRewardResponse.newBuilder().setDrop(drop).build();
MessageUtil.sendMessage(session, 1, rewardResponseValue, build, true);
}
}

View File

@ -16,6 +16,7 @@ public class ActivityMission extends MongoBase {
private int activityState;
private int openType;
private Map<Integer,ActivityProgressInfo> activityProgressInfoMap = new HashMap<>();
private int value;
public ActivityMission(){}
@ -76,4 +77,13 @@ public class ActivityMission extends MongoBase {
public int getOpenType() {
return openType;
}
public int getValue() {
return value;
}
public void setValue(int value) {
updateString("value" ,value);
this.value = value;
}
}

View File

@ -172,6 +172,7 @@ public class BuyGoodsLogic {
int saveAmt = rechargeInfo.getSaveAmt();
rechargeInfo.setSaveAmt(price+saveAmt);
ActivityLogic.getInstance().updateActivityMissionProgress(user, ActivityType.RechargeTotal,rechargeInfo.getSaveAmt(),null);
ActivityLogic.getInstance().updateActivityMissionProgress(user, ActivityType.LUCKYCAT,rechargeInfo.getSaveAmt(),null);
}
buyGoodsTimes.put(goodsId,buyCount);