public override void doUse(MyCharacterController user, GameObject target)
 {
     //base.doUse(user, target);
     initMenu(user);
     initUnselectableItems();
     openMenu();
 }

 public ExplosionDamage(MyCharacterController attacker, MyCharacterController target,FieldActionController.ExplisionLevel level, int damage)
     : base(attacker, target)
 {
     Level = level;
     Damage = damage;
     AllowGainExp = level == FieldActionController.ExplisionLevel.ONE;
 }

 protected override void caneEffect(MyCharacterController user, ObjectEntity target)
 {
     var c = target as MyCharacterController;
     if (c != null) {
         c.registerBuff(new Paralyze(c, BasisParameter.EffectPoint, StatusBuffBasis.CountDownType.TURN));
     }
 }

 public void attackPtoE(MyCharacterController src, MyCharacterController target, int damage, bool isdead)
 {
     string str = "",str2="";
     str = string.Format("{0} は{1} へ{2}ポイントのダメージを与えた。", src.Parameter.Name,target.Parameter.Name, damage);
     if (isdead) str2 = string.Format("\n{0} は倒れた。",target.Parameter.Name);
     if (str.Length + str2.Length != 0) addLog(str+str2);
 }

 protected override void caneEffect(MyCharacterController user, ObjectEntity target)
 {
     var c = target as MyCharacterController;
     if (c != null) {
         c.registerBuff(new MissedSwing(c,BasisParameter.EffectPoint));
     }
 }

 public override void turnEnd(MyCharacterController user)
 {
     base.turnEnd(user);
     if (GameController.Rnd.lottery(ExertionProbability)) {
         GameController.FieldActionController.explosion(user.CurrentPosition, FieldActionController.ExplisionLevel.TWO);
     }
 }

 public override void applyItemEffect(MyCharacterController src, params ObjectEntity[] targets)
 {
     if (Item != null) {
         prevname = Item.Name;
         success = Item.expantionInventory(BasisParameter.EffectPoint);
     }
 }

 protected override void caneEffect(MyCharacterController user, ObjectEntity target)
 {
     if (isTargetObject(target)) {
         var c = (target as MyCharacterController);
         c.registerBuff(new SpeedDown(c, BasisParameter.EffectPoint));
     }
 }

 protected override void caneEffect(MyCharacterController user, ObjectEntity target)
 {
     var c = target as MyCharacterController;
     if (c != null) {
         c.Parameter.levelDown(BasisParameter.EffectPoint);
     }
 }

    void selectGoodEffect(MyCharacterController user)
    {
        int select = GameController.Rnd.Next(effectcount);
        switch (select) {
            case 0:
                user.Parameter.increaseMaxSTR(1, true);
                user.Parameter.increaseCurrentSTR(1, false);
                break;
            case 1:
                user.heal(user.Parameter.MaxHP);
                break;
            case 2:
                user.registerBuff(new InvalidatePoison(user));
                break;
            case 3:
                user.registerBuff(new InvalidateSleep(user));
                break;
            case 4:
                user.registerBuff(new InvalidateHunger(user));
                break;
            case 5:
                user.registerBuff(new AutoItemAppraise(user));
                break;
            case 6:
                user.registerBuff(new SneakWalk(user));
                break;

        }
    }

 public ItemInventoryMenu(MyCharacterController owner)
     : this(owner, delegate { })
 {
     //init();
     SubmitAct = defaultAction;
     CancelAct = () => { };
 }

    public override bool hit(MyCharacterController src, GameObject target, Vector2 currentpos, bool penatrable, bool armorpiercing = false)
    {
        bool ret = false;
        //Debug.Log("TName: " + target.name+","+target.tag);
        if (TagList.isCharacterTag(target.tag) || TagList.isPlayerTag(target.tag))
        {
            MyCharacterController charctl = target.GetComponent<MyCharacterController>();
            GameController.PlayingLogger.hitObject(this.Name, charctl.Parameter.Name);
            if (!charctl.isDodge && !charctl.ParameterOffset.IsFlyingItemDodge)
            {
                if (this.IsCursed)
                {
                    hitEffectWhenCursed(src, target);
                }
                else
                {
                    hitEffect(src, target, currentpos, penatrable, armorpiercing);
                }
                //hitEffect(src, target, currentpos,penatrable,armorpiercing);
                ret = true;
            }
            else
            {
                //GameController.PlayingLogger.attackMiss();
            }

        }
        return ret;
    }

 public override void potionEffect(MyCharacterController user, MyCharacterController target)
 {
     PlayerController p = target as PlayerController;
     if (p != null) {
         p.Parameter.increaseExHP(BasisParameter.EffectPoint);
     }
 }

 public override void turnStart(MyCharacterController user)
 {
     var p = user as PlayerController;
     if (p != null) {
         p.Parameter.WallPenatrableThrow = true;
     }
 }

 public override bool startOperation(MyCharacterController speaker, MyCharacterController own)
 {
     Message.reset();
     Items = GameController.DungeonInformation.ListOfUnpaidCommodityWhichNotExistOnFiled.ToArray();
     initPaymentMenu(speaker as PlayerController);
     return true;
 }

 public StringBoardMenu(MyCharacterController owener, int maxlength)
     : base(rowsize,columnsize,owener,pos, size, "StringBoardMenu")
 {
     CurrentText = new StringBuilder(maxlength);
     MaxLength = maxlength;
     BoardText = new WindowText[rowsize, columnsize];
     Vector2 textpos0 = Window.TextAreaPosition+Vector2.one*WindowConfigure.fontScale(1f);
     for (int r = 0; r < rowsize; r++) {
         Vector2 prevpos = textpos0 + new Vector2(0,r*ymargin);
         for (int c = 0; c < columnsize; c++) {
             float xmargin = c%5==0 ? WindowConfigure.fontScale(1.5f) : WindowConfigure.fontScale(1.2f);
             xmargin = c == 0 ? WindowConfigure.fontScale(0.5f) : xmargin;
             Vector2 textpos = prevpos + new Vector2(xmargin, 0);
             BoardText[r, c] = new WindowText( "", textpos);
             prevpos = textpos;
         }
     }
     //string[] table = createHiraKanaTable();
     setHirakanaTable();
     setSystemText();
     Window.MultiSelectMode = false;
     Vector2 dispsize = new Vector2(WindowConfigure.fontScale(maxlength +6), WindowConfigure.fontScale(1.5f));
     Vector2 disppos = new Vector2(Window.WindowPosition.x + (Window.WindowSize.x/2 - dispsize.x/2),(Window.WindowPosition.y - dispsize.y));
     InputDisplay = new ViewOnlyWindow(disppos, dispsize);
     WindowText prevtext = new WindowText("",InputDisplay.TextAreaPosition + new Vector2(WindowConfigure.fontScale(2f),-WindowConfigure.fontScale(0.3f)));
     InputDisplay.addWindowText(prevtext);
     SubWindows.Add(InputDisplay);
     Window.SkipText.Add("");
     Window.ReplaceText.Add(WhiteSpace,"");
 }

 public override DamageOffset calcOffsetWhenOffensiveSide(DamageOffset offset, MyCharacterController user, MyCharacterController target)
 {
     if (target.Parameter.CharacterElement == this.TargetElemental) {
         offset.addOffensiveSideFinalDamageOffset(levelrate[(int)this.CurrentAbilityLevel]);
     }
     return offset;
 }

 protected override void caneEffect(MyCharacterController user, ObjectEntity target)
 {
     MyCharacterController c = target as MyCharacterController;
     if (c != null) {
         GameController.FieldActionController.objectBullRush(user, c, BasisParameter.BullRushDistance, BasisParameter.EffectPoint);
     }
 }

 public DOTDamage(MyCharacterController target, int damage, bool isdeadly, CauseOfDeathBasis cod)
     : base(null, target)
 {
     Damage = damage;
     IsDeadly = isdeadly;
     COD = cod;
 }

 public override void potionEffect(MyCharacterController user, MyCharacterController target)
 {
     var p = target as PlayerController;
     if (p != null) {
         p.Parameter.addMaxHunger(BasisParameter.EffectPoint);
     }
 }