Example #1
0
func TestLots(t *testing.T) {
	l := lottery.New(rand.New(rand.NewSource(time.Now().UnixNano())))

	dropItems := []lottery.Interface{
		DropItem{ItemName: "エリクサ", DropProb: 5},
		DropItem{ItemName: "エーテル", DropProb: 10},
		DropItem{ItemName: "ポーション", DropProb: 20},
		DropItem{ItemName: "ハズレ", DropProb: 50},
		Trap{TrapName: "地雷", prob: 5},
		Trap{TrapName: "トラバサミ", prob: 10},
	}

	check := 2000000
	countMap := map[lottery.Interface]int{}
	for i := 0; i < check; i++ {
		lotIdx := l.Lots(dropItems...)
		if lotIdx == -1 {
			t.Fatal("lot error")
		}

		switch d := dropItems[lotIdx].(type) {
		case DropItem, Trap:
			countMap[d]++
		}
	}

	for item, count := range countMap {
		result := float64(count) / float64(check) * 100
		prob := float64(item.Prob())

		name := ""
		switch t := item.(type) {
		case DropItem:
			name = t.ItemName
		case Trap:
			name = t.TrapName
		}

		// 0.1 check
		if (prob-0.1) <= result && result < (prob+0.1) {
			fmt.Printf("ok %3.5f%%(%7d) : %s\n", result, count, name)
		} else {
			t.Errorf("error %3.5f%%(%7d) : %s\n", result, count, name)
		}
	}
}
Example #2
0
func TestLot_0to100(t *testing.T) {
	l := lottery.New(rand.New(rand.NewSource(time.Now().UnixNano())))

	testCases := []struct {
		prob   int
		result bool
	}{
		{prob: 120, result: true},
		{prob: 100, result: true},
		{prob: 0, result: false},
		{prob: -1, result: false},
	}

	for _, testCase := range testCases {
		if l.Lot(testCase.prob) != testCase.result {
			t.Errorf("lottery error not %f%%", testCase.prob)
		}
	}
}
Example #3
0
func TestLot(t *testing.T) {
	l := lottery.New(rand.New(rand.NewSource(time.Now().UnixNano())))

	check := 1000000
	prob := float64(4.0) // 4%
	count := 0
	for i := 0; i < check; i++ {
		if l.Lot(int(prob)) {
			count++
		}
	}
	result := float64(count) / float64(check) * 100

	// 0.1 check
	if (prob-0.1) <= result && result < (prob+0.1) {
		fmt.Printf("lottery ok %f%%\n", result)
	} else {
		t.Errorf("lottery error %f%%", result)
	}
}
Example #4
0
func main() {
	lot := lottery.New(rand.New(rand.NewSource(time.Now().UnixNano())))

	check := 1000
	count := 0

	for i := 0; i < check; i++ {

		if lot.LotOf(1, 5) {
			// 1/5の確率
			fmt.Print("アタリ")
			count++
		} else {
			fmt.Print("ハズレ")
		}

	}

	fmt.Println(float32(count)/float32(check)*100, "%")

}
Example #5
0
func TestExploration(t *testing.T) {
	log.SetFlags(log.Llongfile)

	lot := lottery.New(rand.New(rand.NewSource(time.Now().UnixNano())))

	// init repository
	playerRepository := repository.NewPlayer()
	explorationRepository := repository.NewExploration()
	// init factory
	messageFactory := dMessage.NewFactory()
	lotteryFactory := dLottery.NewFactory(&lot)
	enemyFactory := dCharacter.NewEnemyFactory()

	p := dCharacter.NewPlayer("test player")
	e := dExploration.New(dExploration.Identifier("uuid-uuid-uuid"), dDungeon.Tutorial, p.ID)

	// init repository store
	explorationRepository.Store(e)
	playerRepository.Store(p)

	// init service
	explorationService := sExploration.New(
		explorationRepository,
		playerRepository,
		enemyFactory,
		lotteryFactory,
	)
	explorationLogService := sExplorationlog.New(
		explorationRepository,
		playerRepository,
		messageFactory,
	)

	// start

	nowTime, _ := time.ParseInLocation("2006-01-02 15:04:05", "2015-07-20 17:42:40", time.UTC)
	// 探索開始時間(5時間前)
	startTime := nowTime.Add(-5 * time.Hour)
	if err := explorationService.Start(e.ID, startTime); err != nil {
		t.Errorf("exploration start error : %s", err.Error())
	}

	progress, err := explorationService.Progress(e.ID, nowTime)
	if err != nil {
		t.Errorf("exploration progress error : %s", err.Error())
	}

	fmt.Printf("progress count : %s - %s => %d\n", startTime, nowTime, progress)

	e, err = explorationRepository.Resolve(e.ID)
	if err != nil {
		t.Errorf("exploration find error : %s", err.Error())
	}
	pp.Println(e.StartTime, e.PlayState, e.EndTime, e.ProgressCount)

	p, err = playerRepository.Resolve(p.ID)
	if err != nil {
		t.Errorf("player find error : %s", err.Error())
	}
	pp.Println(p)

	messages := explorationLogService.EventLog(e.ID)
	for _, ms := range messages {
		fmt.Printf("%s\n", ms)
	}

	explorationMessage := explorationLogService.ExplorationLog(e.ID)
	line := buildMaxLenSizeLine(explorationMessage)
	fmt.Println(line)
	fmt.Printf("%s\n", explorationMessage)
	fmt.Println(line)
}