Swing错鸡宝的诸侯国二期国力评分代码

package Rating;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import Buffs.KPolicy;
import Buffs.ManCharacter;
import Materials.HistMaterial;
import cqzg.voidMain;
import reality.City;
import reality.Grid;
import reality.Kingdom;
import reality.Man;
import reality.Minister;
import Speller.hs;
public class CountKingdomPower {
	public static boolean gbset_statisticKingdomPower=false;
	public static CountKingdomPower soloInstance=new CountKingdomPower();
	private int annualThreshold=0;
	private int annualRankCnt=14;
	Kingdom kingdom;
	static RateKingdomPowerValueTable valuemap=RateKingdomPowerValueTable.soloInstance;
	private Map<Kingdom,Integer> smkn_annual=new HashMap<Kingdom,Integer>();
	private List<Integer> ndMostPowerful=new LinkedList<Integer>();
	private static List<DVExcelRow> ldver_annual=new ArrayList<DVExcelRow>();
	private static List<DVExcelRow> ldver_total=new ArrayList<DVExcelRow>();
	Map<String,Double> msdFactors=new HashMap<String,Double>();
	Map<String,Double> mlymf=new HashMap<String,Double>();
	public static Map<Kingdom,Double> psmkd_lastRef=new HashMap<Kingdom,Double>();
	//static Map<Kingdom,Integer> psmkn_annualDisasterMinus=new HashMap<Kingdom,Integer>();
	private static double dfactorDecay=0.8;
	private Man pm;
	public static double dKingdomSARValue(Kingdom kingdom,String ps_kvIndex)
	{
		return 0.0;
	}
	public static void annualStatisticEntry(int pianno)
	{
		if (gbset_statisticKingdomPower)
			soloInstance.annualStatistic(pianno);
	}
	public static void printAnnualKingdomRate()
	{
		for (DVExcelRow looper:ldver_total)
			looper.ToprintLine();
	}
	private double getvty(String pskeyName)
	{
		if (!msdFactors.containsKey(pskeyName))
			return 0;
		return msdFactors.get(pskeyName);
	}

	private void annualStatistic(int pianno)
	{

		annualThreshold=0;
		if (pianno==-375)
			annualRankCnt=11;
		else if (pianno==-256)
			annualRankCnt=8;//猃狁会在BC236掩盖掉韩国
		smkn_annual.clear();
		ndMostPowerful.clear();
		ndMostPowerful.add(0);
		ldver_annual.clear();
		
		for (Kingdom kingdom:Kingdom.kingdoms)
			if (kingdom.alive)
			{
				this.kingdom=kingdom;
				msdFactors.clear();
				countKingdomPower();
				double ldkingdomPow=sumAllFactors(msdFactors);
				if ("周".equals(kingdom.getKingdomName())&&pianno<-367)
					ldkingdomPow+=voidMain.gameInstance.global.celestial_dignity+1000+(voidMain.anno<=-771?1500:0);
				Integer npower= (int)ldkingdomPow;
				int ln_insertPos=nInsertRankPos(npower);
				vShiftRatingTomemory();
				if (ln_insertPos>annualRankCnt)
					continue;
				if (pianno>=-230&&npower<=1500)
					continue;
				ndMostPowerful.add(ln_insertPos,npower);								
				DVExcelRow dver=new DVExcelRow(kingdom,npower,pianno);
				ldver_annual.add(ln_insertPos-1,dver);
			}
		for (int wntoRecord=ldver_annual.size()-1;wntoRecord>=annualRankCnt;wntoRecord--)
			ldver_annual.remove(wntoRecord);
		ldver_total.addAll(ldver_annual);
		for (DVExcelRow printlooper:ldver_annual)
			printlooper.ToprintLine();

	}
	private void vShiftRatingTomemory() 
	{
		//no more used
		mlymf.clear();
		mlymf.putAll(msdFactors);		
	}
	private int nInsertRankPos(int pnpower)
	{	
		int ln_insPos=ndMostPowerful.size();
		while (pnpower>ndMostPowerful.get(ln_insPos-1)&&ln_insPos>1)
			ln_insPos--;
		return ln_insPos;
		
	}
	public double sumAllFactors(Map<String,Double> poMsdFactors)
	{
		double rdPowerRate=0;
		for (Double ld:poMsdFactors.values())
			if (ld!=null)
				rdPowerRate+=ld;
		//rdPowerRate-=getvty(ps_stain)*2;
		return rdPowerRate;
	}
	private static final String ps_restPower="restPower";
	private static final String ps_prestige="prestige";
	private static final String ps_reputation="reputation";
	private static final String ps_credit="credit";
	private static final String ps_stain="stain";
	private static final String ps_disaster="disaster";


	private static final String[] sfas_IndexType=new String[] {ps_restPower,ps_prestige,ps_reputation,ps_credit,ps_stain,ps_disaster};
	private final int nNegativeMSDFactor(int pnIndexType) 
	{
		switch (pnIndexType)
		{
		case 0:case 4:case 5:return -1;
		}
		return 1;
	}
	private void KingdomIndexSAR(int pnIndexType,double pdThisYearFactor,double pdLastYearFactor)
	{
		double dnewValue=KSARBundle.getKingdomThisYearIndex(pnIndexType, kingdom)*(nNegativeMSDFactor(pnIndexType));
		msdFactors.put(sfas_IndexType[pnIndexType],dnewValue*pdThisYearFactor);
		double doldValue=kingdom.kibLastYear.oac[pnIndexType]*(nNegativeMSDFactor(pnIndexType));
		msdFactors.put(sfas_IndexType[pnIndexType]+"_SAR",doldValue*pdLastYearFactor);
	}
	private double getKingdomRateValue(String psvk)
	{
		switch (psvk)
		{
		case ps_prestige:return kingdom.prestige*1.0;
		case ps_reputation:return kingdom.reputation*1.0;
		case ps_stain:return kingdom.stain*1.0;
		}
		return 0;
	}
	public double countKingdomPower()
	{
		if (kingdom==null)
			return 0.0;
		tanSkill=new int[]{0,0,0,0,0,0,0,0,0};
		double dLastYearRef=0;
		msdFactors.clear();
		//calcKingdomPropFloating(ps_reputation,0.9,0.7);
		//calcKingdomPropFloating(ps_prestige,1.2,1);
		//calcKingdomPropFloating(ps_stain,0.7,1.8);
		KingdomIndexSAR(0,1.0,0.9);
		KingdomIndexSAR(1,1.0,0.9);
		KingdomIndexSAR(2,1.0,0.9);
		KingdomIndexSAR(3,1.0,0.9);
		KingdomIndexSAR(4,1.0,0.9);
		KingdomIndexSAR(5,1.0,0.9);
		peak_pol=0;peak_wis=0;peak_war=0;
		double rrkp=0.0;
		msdFactors.put("KPowerRank",valuemap.fmsr_kingdomRank.get(kingdom.kingdompowerRank).doubleValue());
		double kingPowerFix=0;
		String lsmpt=kingdom.getmonarchPowerType();		
		if (valuemap.fmsr_kingdomPowerRate_MonarchPower.containsKey(lsmpt))
			msdFactors.put("MonarchPower",valuemap.fmsr_kingdomPowerRate_MonarchPower.get(lsmpt).doubleValue());
		double gridRate=rAllGridRate();
		rrkp=gridRate;
		double policyRate=rAllPolicyRate();
		rrkp=policyRate;
		double menRate=rAllMenRate();
		double dmonarchFactor=monarchIndex();
		rrkp=dmonarchFactor/50;
		double rdpol=RateKingdomPowerValueTable.soloInstance.dladderAbilityPoint(peak_pol)/1;
		double rdwis=RateKingdomPowerValueTable.soloInstance.dladderAbilityPoint(peak_wis)/1;
		double rdwar=RateKingdomPowerValueTable.soloInstance.dladderAbilityPoint(peak_war)/1;
		msdFactors.put("peakManAbility",(rdpol*0.8+rdwis*0.6+rdwar*0.4)/5);
		int rnSkillTop=0;
		for (int lnSkillIndex=0;lnSkillIndex<9;lnSkillIndex++) rnSkillTop+=RateKingdomPowerValueTable.datavrap_skillRate[tanSkill[lnSkillIndex]];
		msdFactors.put("peakManSkills",rnSkillTop*0.25);//was 0.6 for season2
		msdFactors.put("KingdomRank", getKingdomRankRateValue()+0.0);
		//turf
		
		return rrkp;
	}
	private int getKingdomRankRateValue()
	{
		
		if (RateKingdomPowerValueTable.soloInstance.fmsr_KingdomRankBase.containsKey(kingdom.kingdomRank))
			return RateKingdomPowerValueTable.soloInstance.fmsr_KingdomRankBase.get(kingdom.kingdomRank);
		return 0;
	}
	private double rAllMenRate() 
	{
		double rrkp=0;
		for (Man man:kingdom.menlist)
			if (man.alive&&man.bvirtual==false)
			{
				double ldmanValue=dmanRate(man);
				double dmanAgeFactor=1.0;
				if (man.age<10)
					dmanAgeFactor=0.25;
				else if (man.age<20)
					dmanAgeFactor=0.5;
				else if (man.age>60)
					dmanAgeFactor=0.4;
				rrkp+=dmanRate(man)*dmanAgeFactor+25;
			}
		msdFactors.put("allMenValue",rrkp);
		return rrkp;
	}
	int peak_pol=0,peak_wis=0,peak_war=0;
	int[] tanSkill;
	private double dmanRate(Man man)
	{
		peak_pol=Math.max(peak_pol, man.politic);
		peak_wis=Math.max(peak_wis, man.brain);
		peak_war=Math.max(peak_war, man.warfare);
		tanSkill[0]=Math.max(tanSkill[0], man.kungfu);
		tanSkill[1]=Math.max(tanSkill[1], man.archery);
		tanSkill[2]=Math.max(tanSkill[2], man.knowledge);
		tanSkill[3]=Math.max(tanSkill[3], man.agriculture);
		tanSkill[4]=Math.max(tanSkill[4], man.commercial);
		tanSkill[5]=Math.max(tanSkill[5], man.jural);		
		tanSkill[6]=Math.max(tanSkill[6], man.diplomat);
		tanSkill[7]=Math.max(tanSkill[7], man.engineering);
		tanSkill[8]=Math.max(tanSkill[8], man.maritime);
		return manAbilitySum(man,0.005,0.006,0.003,0.004,0.005);
	}

	private double rAllPolicyRate() 
	{
		double rrkp=0;
		for (KPolicy lkpolicy:kingdom.policies)
			if (valuemap.fmsr_kpolicy.containsKey(lkpolicy.name))
				rrkp+=valuemap.fmsr_kpolicy.get(lkpolicy.name);
		msdFactors.put("KPolicies", rrkp);
		return rrkp;
	}
	private double rAllGridRate()
	{
		double rrkp=0;
		double rdcities=0;
		double rdtechan=0;
		double grid_KeyGrid=0.0;
		for (Grid grid:kingdom.gridlist)
		{
			City city=grid.city;
			rrkp+=45;
			if (grid.techan!=null)
				rdtechan+=techanValue(grid,grid.techan);		
			grid_KeyGrid+=RateKingdomPowerValueTable.keyGridValue(grid.gridname);
			if (city==null)
				continue;
			if ("".equals(city.cityrank)==false)
				rdcities+=cityRank(city);
		}
		msdFactors.put("grids", rrkp);
		msdFactors.put("cities", rdcities);
		msdFactors.put("techan", rdtechan);
		if (grid_KeyGrid>0.0)
			msdFactors.put("keygrid", rdtechan);	
		return rrkp;
	}
	private double techanValue(Grid pgrid,HistMaterial pmtechan)
	{
		String vsname=pmtechan.namech;
		if (!valuemap.fmsr_cityrank.containsKey(vsname))
			return 35.0;
		return RateKingdomPowerValueTable.dtechanRate(pgrid,vsname);
	}
	private double cityRank(City city)
	{
		double rrkp=0;
		String vsrank=city.cityrank;//assert not "" or null
		if (!valuemap.fmsr_cityrank.containsKey(vsrank))
			return 35.0;
		double rd=valuemap.fmsr_cityrank.get(vsrank);		
		rrkp+=30+rd;
		return rrkp;
	}
	public double monarchIndex()
	{
		double rrkp=0.0;
		Man monarch=kingdom.monarch;
		if (monarch==null)
			return 0.0;
		if (monarch.bvirtual)
			return 0.0;
		double monarchPoint=manAbilitySum(monarch,0.054,0.045,0.037,0.04,0.045);
		msdFactors.put("MonarchPoint",monarchPoint);
		rrkp+=monarchPoint;
		if (kingdom.heir!=null)
			msdFactors.put("heirPoint",manAbilitySum(kingdom.heir,0.032,0.027,0.022,0.031,0.032));
		pm=kingdom.getPM();
		if (pm!=null)
			if ("范座".equals(pm.getname()))
			{
				kingdom.getPM();
			}
		if (pm!=null)
			msdFactors.put("PMPoint",manAbilitySum(pm,0.022,0.021,0.017,0.31,0.27));
		return rrkp/4;
	}

	public static double manAbilitySum(Man man,double pdpolFac,double pdwisFac,double pdwarFac,double pdSkill,double pdProp)
	{

		double rdpol=valuemap.dladderAbilityPoint(man.politic)*pdpolFac;
		double rdwis=valuemap.dladderAbilityPoint(man.brain)*pdwisFac;
		double rdwar=valuemap.dladderAbilityPoint(man.warfare)*pdwarFac;
		double rdskills=Double.valueOf(valuemap.nmanSkillRate(man))*pdSkill;
		double rdprop=ManCharacter.nmanTZRate(man)*pdProp;
		return rdpol+rdwis+rdwar+rdprop+rdskills;
	}
	private double peakAbilitySum(int pnpol,double pdpolFac,int pnwis,double pdwisFac,int pnwar,double pdwarFac)
	{
		double rdpmv=pnpol*pdpolFac+pnwis*pdwisFac+pnwar*pdwarFac;
		msdFactors.put("peakManValue",rdpmv);
		return rdpmv;
	}
}
class DVExcelRow
{
	int ianno=0;
	int nvalue=0;
	String skingdomName="";
	String sKingdomDesc="";
	String sMonarchName="";
	String sanno="";
	Kingdom kingdom;
	String sPMStr="";
	public DVExcelRow(Kingdom kingdom,int cnValue,int cianno)
	{
		this.kingdom=kingdom;
		this.skingdomName=kingdom.kingdomnameDesc();
		String smpt=kingdom.getmonarchPowerType();
		if (kingdom.monarch!=null)			
			this.sMonarchName=kingdom.getmonarchName(Kingdom.MonarchNamePattern.shicheng);
		sPMStr="";
		Man pm=kingdom.getPM();
		if (pm!=null)
		{
			if (pm.asminister!=null)
				sPMStr+=pm.asminister.ministerTitle;
			else if ("".equals(sPMStr))
				sPMStr=" 相 ";
			sPMStr+=" "+pm.getname();
			if (kingdom.bbipm)
			{
				sPMStr="双相制：";
			}
				
		}
			
		if (smpt.length()>0 || sMonarchName.length()>0 || sPMStr.length()>0)
			sKingdomDesc=smpt+" "+sMonarchName+" "+sPMStr;
		else
			sKingdomDesc="没有统治者资料";
		this.nvalue=cnValue;
		this.ianno=cianno;
		int ci_absAnno=-cianno;
		sanno="BC"+ci_absAnno;
	}

	public void ToprintLine() 
	{
		System.out.println(skingdomName+","+sKingdomDesc+","+nvalue+","+sanno);
		
	}

}

/*
manprop map manrate
kpol map krate
techan map tcrate
city polyType map cvalue

*/

其他配置片段

public class InitManPropAsValue {
	
	Map<String,Integer> rmsn=new HashMap<String,Integer>();
	private void ivr(String pstz,int pntzrv)
	{
		if (ManCharacter.smstz.containsKey(pstz))
			return;
		rmsn.put(pstz, pntzrv);
	}
	public static Map<String,Integer> InitManCharacterRateValue()
	{
		InitManPropAsValue instance=new InitManPropAsValue();
		if (ManCharacter.gbsetStatisticAnnualMan||CountKingdomPower.gbset_statisticKingdomPower)
			instance.InitManCharacterRateValue_kernel();
		return instance.rmsn;
	}

public class RateKingdomPowerValueTable {
	
	public static RateKingdomPowerValueTable soloInstance=new RateKingdomPowerValueTable();
	Map<String,Integer> fmsr_KingdomRankBase=new HashMap<String,Integer>()
	{
		{
			put("帝",3200);
			put("王",2000);
			put("公",800);
			put("侯",600);
			put("伯",400);
			put("子",200);
			put("男",100);
		}
	};

	public static Map<String,Integer> fmsr_cityrank=new HashMap<String,Integer>()
	{
		{
			put("cot",650);
			put("都会",610);
			put("商都",560);			
			put("大城",530);
			put("名城",450);
			put("小都",380);			
			put("小城",320);			
			put("都邑",240);			
			put("堡垒",300);
			put("邑",160);
	
		}			
	};
	public static double dtechanRate(Grid grid,String pstc)
	{

		
		if (pstc.contains("盐"))
			return 350;
		if (pstc.contains("马"))
			return 280;

		if (soloInstance.fmsr_techan.containsKey(pstc))
			return soloInstance.fmsr_techan.get(pstc);
		return 60;
	}
	public static final Integer datavrap_skillRate[]=new Integer[] {0,90,250,560,980,1560}; 
	public int nmanSkillRate(Man man)
	{
	//	int iq=Math.min(700, brain)+Math.max(0, brain-700)*1+Math.max(0, brain-900)*3;
	//	int zz=Math.min(700, this.politic)+Math.max(0, this.politic-700)*1+Math.max(0, this.politic-900)*3;
	//	int tactic=Math.min(700, this.warfare)+Math.max(0, this.warfare-700)*1+Math.max(0, this.warfare-900)*3;
		int skills=0;
		skills+=datavrap_skillRate[man.kungfu];
		skills+=datavrap_skillRate[man.archery];
		skills+=datavrap_skillRate[man.knowledge];
		skills+=datavrap_skillRate[man.agriculture];
		skills+=datavrap_skillRate[man.commercial];
		skills+=datavrap_skillRate[man.engineering];
		skills+=datavrap_skillRate[man.diplomat];
		skills+=datavrap_skillRate[man.jural];
		skills+=datavrap_skillRate[man.maritime];
		return skills;
	}
	Map<String,Integer> fmsr_techan=new HashMap<String,Integer>()
	{
		{
			put("盐",320);
			put("丝绸",150);
			put("玉",400);
			put("铁",240);
			put("铁器",450);
			put("锐铁",280);
			put("铜",222);
			put("青铜",256);
			put("金属",350);
			put("丹砂",278);
			
			put("羊",170);
			put("牛",380);
			put("野味",250);
			put("禽兽",140);
			put("珍兽",455);
			put("白狐",334);
			
			put("藏活",460);
			put("驴皮",310);
			put("阿胶",340);
			put("蓍草",410);
			put("黄金",850);
			
			put("陶",140);
			put("桐木",166);
			put("木材",140);
			put("牧场",240);
			put("麻布",110);
			put("药",145);
			put("茶",124);
			put("牛旄",56);
			put("龟",0);			
			put("党参",0);
			
			put("锡",360);
			
			put("紫草",220);
			put("腌鱼",45);
			
		//	put("",0);				
		}			
	};
	Map<String,Integer> fmsr_kpolicy=new HashMap<String,Integer>()
	{
		{
			//put("",76);
		}			
	};
	Map<String,Integer> fmsr_kingdomRank=new HashMap<String,Integer>()
	{
		{
			put(InitKingdom.superpower,12800);
			put(InitKingdom.greatpower,7200);
			put(InitKingdom.middlepower,3800);
			put(InitKingdom.smallpower,1700);
			put(InitKingdom.poleis,500);
			put(InitKingdom.puppetKingdom,-200);
			//season2
			//小国 1700
			//列国 2400
			//列强 4200
			//霸主 6400
		}			
	};
	Map<String,Integer> fmsr_kingdomPowerRate_MonarchPower=new HashMap<String,Integer>()
	{
		{
			put(KPolicy.king_despot,1320);
			put(KPolicy.king_fedual,850);
			put(KPolicy.king_weak,340);
			put(KPolicy.king_regent,520);
			put(KPolicy.king_underage_regent,180);
			put(KPolicy.king_underage_dogwa,140);
			put(KPolicy.king_lords,210);
			put(KPolicy.king_quanchen,-200);
			put(KPolicy.king_noking,-360);
			put(KPolicy.king_mandatePM,-150);
			put(KPolicy.king_noking,-250);
		}
	};
	public double disaster_restPowerReduce(String ps_disasterType)
	{
		switch (ps_disasterType)
		{
		case Speller.hs.drought:return 15.0;
		case Speller.hs.flood :return 18.0;
		case Speller.hs.famine :return 25.0;
		case Speller.hs.chaos :return 37.0;
		case Speller.hs.insect :return 15.0;
		case Speller.hs.badHarvest :return 21.0;
		case Speller.hs.goodHarvest :return -25.0;
		case Speller.hs.anarchy :return 40.0;
		case Speller.hs.disaster_fire :return 8.0;
		}
		return 0.0;
	}
	public int disasterMinusPoint(String ps_disasterType)
	{
		switch (ps_disasterType)
		{
		case Speller.hs.drought:return 450;
		case Speller.hs.flood :return 270;
		case Speller.hs.famine :return 370;
		case Speller.hs.chaos :return 560;
		case Speller.hs.insect :return 210;
		case Speller.hs.badHarvest :return 160;
		case Speller.hs.goodHarvest :return -210;
		case Speller.hs.anarchy :return 440;
		case Speller.hs.disaster_fire :return 150;
		}
		return 0;
	}
	public double dladderAbilityPoint(int pnPol)
	{
		if (pnPol>950)
			return (pnPol-950)*7.5+900*7;
		if (pnPol>900)
			return (pnPol-900)*7+850*6;
		if (pnPol>850)
			return (pnPol-850)*6+800*5.4;
		if (pnPol>800)
			return (pnPol-800)*5.4+700*4.7;
		if (pnPol>750)
			return (pnPol-750)*4.7+700*4;
		if (pnPol>700)
			return (pnPol-700)*4+700*3.5;
		return pnPol*3.2;
	}

	public static int keyGridValue(String psGridName)
	{
		switch (psGridName)
		{
		case "函谷":return 560;
		case "孟津":return 350;
		case "鄗":return 240;
		case "潼关":return 350;
		case "井陉":return 340;
		case "盂口":return 256;
		case "阏与":return 242;
		case "虞":return 222;
		case "轵":return 351;
		case "渑池":return 125;
		case "崤":return 315;
		case "宜阳":return 365;
		case "郑":return 76;
		case "汉中":return 65;
		case "江关":return 153;
		case "昭关":return 165;
		case "制":return 350;
		case "河曲":return 241;
		case "峣关":return 217;
		case "壶口":return 240;
		case "上党":return 187;
	
		}
		return 0;
	}
}