source: 2015/26/MikkoL/JRPG/JRPG/JRPG/Battle/Characters/CharacterBase.cs @ 6304

Revision 6304, 16.7 KB checked in by mijoliim, 5 years ago (diff)

Taistelut melkein toimivat.

Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using Jypeli;
6
7public class CharacterBase
8{
9    public _BaseStats BaseStats { get; set; }
10    public _CurrentStats CurrentStats { get; set; }
11    public _StatGrowth StatGrowth { get; set; }
12    public _GrowthRates GrowthRates { get; set; }
13
14    public IntMeter CurrentHP { get; set; }
15    public IntMeter CurrentSP { get; set; }
16    public Action OnCurrentHPChange;
17    public Action OnCurrentSPChange;
18
19    public string Name { get; set; }
20
21    public double BaseWaitTimeInSeconds = 2.2;
22    public double WaitTime
23    {
24        get
25        {
26            return BattleAlgorithms.WaitTime(BaseWaitTimeInSeconds, CurrentStats.Spd);
27        }
28    }
29
30    public DoubleMeter WaitTimeMeter { get; set; }
31
32    public double ElapsedTime { get; set; }
33    public bool CanMakeAction { get; set; }
34    public bool IsDead { get; set; }
35
36    public int Level = 1;
37    public const int MaxLevel = 99;
38    public int LevelsGained = 0;
39
40    public int Experience { get; set; }
41
42    public int BaseExperience = 24;
43    public double ExpMultiplier = 1.5;
44    public int ExperienceToNextLevel { get; set; }
45
46    public List<AttackBase> LearnedAttacks { get; set; }
47    public List<SkillBase> LearnedSkills { get; set; }
48
49    public int Index { get; set; }
50
51    public Image Idle { get; set; }
52
53    public class _BaseStats
54    {
55        public int HP = 45;
56        public int SP = 45;
57        public int Str = 10;
58        public int Def = 5;
59        public int Skill = 5;
60        public int Res = 5;
61        public int Spd = 5;
62        public int Luck = 5;
63    }
64    public class _CurrentStats : _BaseStats
65    {
66        /*
67        public new int HP = 45;
68        public new int SP = 45;
69        public new int Str = 10;
70        public new int Def = 5;
71        public new int Skill = 5;
72        public new int Res = 5;
73        public new int Spd = 5;
74        public new int Luck = 5;*/
75    }
76    public class _StatGrowth : _BaseStats
77    {
78        public new int HP = 0;
79        public new int SP = 0;
80        public new int Str = 0;
81        public new int Def = 0;
82        public new int Skill = 0;
83        public new int Res = 0;
84        public new int Spd = 0;
85        public new int Luck = 0;
86
87        public void Reset()
88        {
89            HP = 0;
90            SP = 0;
91            Str = 0;
92            Def = 0;
93            Skill = 0;
94            Res = 0;
95            Spd = 0;
96            Luck = 0;
97        }
98    }
99    public class _GrowthRates
100    {
101        public int HP = 100;
102        public int SP = 100;
103        public int Str = 50;
104        public int Def = 40;
105        public int Skill = 50;
106        public int Res = 30;
107        public int Spd = 20;
108        public int Luck = 20;
109    }
110
111    public void ResetHPMeter()
112    {
113        if (CurrentStats.HP > CurrentHP.MaxValue)
114        {
115            CurrentHP.MaxValue = CurrentStats.HP;
116        }
117        CurrentHP.Value = CurrentStats.HP;
118    }
119    public void ResetSPMeter()
120    {
121        if (CurrentStats.SP > CurrentSP.MaxValue)
122        {
123            CurrentSP.MaxValue = CurrentStats.SP;
124        }
125        CurrentSP.Value = CurrentStats.SP;
126    }
127    public void ResetWaitMeter()
128    {
129        WaitTimeMeter.MaxValue = WaitTime;
130    }
131
132    public CharacterBase()
133    {
134        InitializeCharacter();
135    }
136
137    void InitializeCharacter()
138    {
139        BaseStats = new _BaseStats();
140        CurrentStats = new _CurrentStats();
141
142        CurrentStats.HP = BaseStats.HP;
143        CurrentStats.SP = BaseStats.SP;
144        CurrentStats.Str = BaseStats.Str;
145        CurrentStats.Def = BaseStats.Def;
146        CurrentStats.Skill = BaseStats.Skill;
147        CurrentStats.Res = BaseStats.Res;
148        CurrentStats.Spd = BaseStats.Spd;
149        CurrentStats.Luck = BaseStats.Luck;
150
151        CurrentHP = new IntMeter(CurrentStats.HP, 0, CurrentStats.HP);
152        CurrentSP = new IntMeter(CurrentStats.SP, 0, CurrentStats.SP);
153        WaitTimeMeter = new DoubleMeter(0, 0, WaitTime);
154
155        CurrentHP.Changed += delegate
156        {
157            if (OnCurrentHPChange != null) OnCurrentHPChange.Invoke();
158        };
159        CurrentSP.Changed += delegate
160        {
161            if (OnCurrentSPChange != null) OnCurrentSPChange.Invoke();
162        };
163
164        ExperienceToNextLevel = BaseExperience;
165        LearnedAttacks = new List<AttackBase>();
166        LearnedSkills = new List<SkillBase>();
167        LearnableAttacks.Load();
168        LearnableSkills.Load();
169        CheckForLearnableAttacksAndSkills();
170    }
171
172    #region StatGrowth and Level Up
173
174    public void GainExperience(int exp)
175    {
176        if (Level < MaxLevel)
177        {
178            Experience += exp;
179
180            if (Experience >= ExperienceToNextLevel)
181            {
182                Experience -= ExperienceToNextLevel;
183                if (Experience < 0) throw new Exception("Experience shouldn't be below zero");
184                LevelsGained++;
185                LevelUp();
186                CalculateExperienceToNextLevel();
187                GainExperience(0);
188            }
189        }
190    }
191    void CalculateExperienceToNextLevel()
192    {
193        double exp = (double)ExperienceToNextLevel;
194        exp *= ExpMultiplier;
195        ExperienceToNextLevel = (int)Math.Round(exp, MidpointRounding.AwayFromZero);
196    }
197    void LevelUp()
198    {
199        Level++;
200        _CurrentStats PreviousStats = CurrentStats;
201
202        if (CurrentStats.HP < 999)
203        {
204            int r = RandomInt(0,100);
205
206            if (GrowthRates.HP >= 100 && GrowthRates.HP < 200)
207            {
208                int i = 100 - GrowthRates.HP;
209
210                CurrentStats.HP++;
211                StatGrowth.HP++;
212
213                if (i > r)
214                {
215                    CurrentStats.HP++;
216                    StatGrowth.HP++;
217
218                    if (i > r)
219                    {
220                        CurrentStats.HP++;
221                        StatGrowth.HP++;
222
223                        if (i / 2 > r)
224                        {
225                            CurrentStats.HP++;
226                            StatGrowth.HP++;
227
228                            if (i / 3 > r)
229                            {
230                                CurrentStats.HP++;
231                                StatGrowth.HP++;
232
233                                if (i / 4 > r)
234                                {
235                                    CurrentStats.HP++;
236                                    StatGrowth.HP++;
237                                }
238                            }
239                        }
240                    }
241                }
242            }
243            else if (GrowthRates.HP >= 200)
244            {
245                int i = 200 - GrowthRates.HP;
246
247                CurrentStats.HP += 2;
248                StatGrowth.HP += 2;
249
250                if (i > r)
251                {
252                    CurrentStats.HP++;
253                    StatGrowth.HP++;
254
255                    if (i / 2 > r)
256                    {
257                        CurrentStats.HP++;
258                        StatGrowth.HP++;
259
260                        if (i / 3 > r)
261                        {
262                            CurrentStats.HP++;
263                            StatGrowth.HP++;
264
265                            if (i / 4 > r)
266                            {
267                                CurrentStats.HP++;
268                                StatGrowth.HP++;
269                            }
270                        }
271                    }
272                }
273            }
274            else
275            {
276                if (GrowthRates.HP > r)
277                {
278                    CurrentStats.HP++;
279                    StatGrowth.HP++;
280
281                    if (GrowthRates.HP / 2 > r)
282                    {
283                        CurrentStats.HP++;
284                        StatGrowth.HP++;
285
286                        if (GrowthRates.HP / 3 > r)
287                        {
288                            CurrentStats.HP++;
289                            StatGrowth.HP++;
290
291                            if (GrowthRates.HP / 4 > r)
292                            {
293                                CurrentStats.HP++;
294                                StatGrowth.HP++;
295                            }
296                        }
297                    }
298                }
299            }
300       
301        }
302
303        if (CurrentStats.SP < 999)
304        {
305            int r = RandomInt(0,100);
306
307            if (GrowthRates.SP >= 100)
308            {
309                int i = 100 - GrowthRates.SP;
310
311                CurrentStats.SP++;
312                StatGrowth.SP++;
313
314                if (i > r)
315                {
316                    CurrentStats.SP++;
317                    StatGrowth.SP++;
318
319                    if (i / 2 > r)
320                    {
321                        CurrentStats.SP++;
322                        StatGrowth.SP++;
323
324                        if (i / 3 > r)
325                        {
326                            CurrentStats.SP++;
327                            StatGrowth.SP++;
328
329                            if (i / 4 > r)
330                            {
331                                CurrentStats.SP++;
332                                StatGrowth.SP++;
333                            }
334                        }
335                    }
336                }
337            }
338            else
339            {
340                if (GrowthRates.SP > r)
341                {
342                    CurrentStats.SP++;
343                    StatGrowth.SP++;
344
345                    if (GrowthRates.SP / 2 > r)
346                    {
347                        CurrentStats.SP++;
348                        StatGrowth.SP++;
349
350                        if (GrowthRates.SP / 3 > r)
351                        {
352                            CurrentStats.SP++;
353                            StatGrowth.SP++;
354
355                            if (GrowthRates.SP / 4 > r)
356                            {
357                                CurrentStats.SP++;
358                                StatGrowth.SP++;
359                            }
360                        }
361                    }
362                }
363            }
364        }
365
366        if (CurrentStats.Str < 255)
367        {
368            if (GrowthRates.Str >= 100)
369            {
370                int i = 100 - GrowthRates.Str;
371
372                CurrentStats.Str++;
373                StatGrowth.Str++;
374
375                if (i > RandomInt(0,100))
376                {
377                    CurrentStats.Str++;
378                    StatGrowth.Str++;
379                }
380            }
381            else
382            {
383                if (GrowthRates.Str > RandomInt(0,100))
384                {
385                    CurrentStats.Str++;
386                    StatGrowth.Str++;
387                }
388            }
389        }
390
391        if (CurrentStats.Def < 255)
392        {
393            if (GrowthRates.Def >= 100)
394            {
395                int i = 100 - GrowthRates.Def;
396
397                CurrentStats.Def++;
398                StatGrowth.Def++;
399
400                if (i > RandomInt(0,100))
401                {
402                    CurrentStats.Def++;
403                    StatGrowth.Def++;
404                }
405            }
406            else
407            {
408                if (GrowthRates.Def > RandomInt(0,100))
409                {
410                    CurrentStats.Def++;
411                    StatGrowth.Def++;
412                }
413            }
414        }
415
416        if (CurrentStats.Skill < 255)
417        {
418            if (GrowthRates.Skill >= 100)
419            {
420                int i = 100 - GrowthRates.Skill;
421
422                CurrentStats.Skill++;
423                StatGrowth.Skill++;
424
425                if (i > RandomInt(0,100))
426                {
427                    CurrentStats.Skill++;
428                    StatGrowth.Skill++;
429                }
430            }
431            else
432            {
433                if (GrowthRates.Skill > RandomInt(0,100))
434                {
435                    CurrentStats.Skill++;
436                    StatGrowth.Skill++;
437                }
438            }
439        }
440
441        if (CurrentStats.Res < 255)
442        {
443            if (GrowthRates.Res >= 100)
444            {
445                int i = 100 - GrowthRates.Res;
446
447                CurrentStats.Res++;
448                StatGrowth.Res++;
449
450                if (i > RandomInt(0,100))
451                {
452                    CurrentStats.Res++;
453                    StatGrowth.Res++;
454                }
455            }
456            else
457            {
458                if (GrowthRates.Res > RandomInt(0,100))
459                {
460                    CurrentStats.Res++;
461                    StatGrowth.Res++;
462                }
463            }
464        }
465
466        if (CurrentStats.Spd < 99)
467        {
468            if (GrowthRates.Spd >= 100)
469            {
470                int i = 100 - GrowthRates.Spd;
471
472                CurrentStats.Spd++;
473                StatGrowth.Spd++;
474
475                if (i > RandomInt(0,100))
476                {
477                    CurrentStats.Spd++;
478                    StatGrowth.Spd++;
479                }
480            }
481            else
482            {
483                if (GrowthRates.Spd > RandomInt(0,100))
484                {
485                    CurrentStats.Spd++;
486                    StatGrowth.Spd++;
487                }
488            }
489        }
490
491        if (CurrentStats.Luck < 99)
492        {
493            if (GrowthRates.Luck >= 100)
494            {
495                int i = 100 - GrowthRates.Luck;
496
497                CurrentStats.Luck++;
498                StatGrowth.Luck++;
499
500                if (i > RandomInt(0,100))
501                {
502                    CurrentStats.Luck++;
503                    StatGrowth.Luck++;
504                }
505            }
506            else
507            {
508                if (GrowthRates.Luck > RandomInt(0,100))
509                {
510                    CurrentStats.Luck++;
511                    StatGrowth.Luck++;
512                }
513            }
514        }
515
516        if (PreviousStats == CurrentStats)
517        {
518            int i = RandomInt(1,3);
519            int stat = RandomInt(0,8);
520
521            switch (stat)
522            {
523                case 0:
524                    CurrentStats.HP += i;
525                    StatGrowth.HP += i;
526                    break;
527                case 1:
528                    CurrentStats.SP += i;
529                    StatGrowth.SP += i;
530                    break;
531                case 2:
532                    CurrentStats.Str += i;
533                    StatGrowth.Str += i;
534                    break;
535                case 3:
536                    CurrentStats.Def += i;
537                    StatGrowth.Def += i;
538                    break;
539                case 4:
540                    CurrentStats.Skill += i;
541                    StatGrowth.Skill += i;
542                    break;
543                case 5:
544                    CurrentStats.Res += i;
545                    StatGrowth.Res += i;
546                    break;
547                case 6:
548                    CurrentStats.Spd += i;
549                    StatGrowth.Spd += i;
550                    break;
551                case 7:
552                    CurrentStats.Luck += i;
553                    StatGrowth.Luck += i;
554                    break;
555            }
556        }
557    }   
558
559    int RandomInt(int a, int b)
560    {
561        return RandomGen.NextInt(a,b);
562    }
563
564    #endregion
565
566
567    #region Attack and Skill learning
568
569    public class LearnableAttacks
570    {
571        public static List<AttackBase> Attacks = new List<AttackBase>();
572
573        public static AttackBase Attack = AttackList.Attack();
574
575        public static void Load()
576        {
577            Attacks.Clear();
578            Attack.LearnAtLevel = 1; Attacks.Add(Attack);
579        }
580       
581    }
582    public class LearnableSkills
583    {
584        public static List<SkillBase> Skills = new List<SkillBase>();
585
586        public static void Load()
587        {
588            Skills.Clear();
589        }
590    }
591
592
593    void CheckForLearnableAttacksAndSkills()
594    {
595        LearnedAttacks.Clear();
596        LearnedSkills.Clear();
597
598        for (int i = 0; i < LearnableAttacks.Attacks.Count; i++)
599        {
600            if (LearnableAttacks.Attacks[i].LearnAtLevel <= Level)
601            {
602                //AttackBase ATK = new AttackBase();
603                //ATK = LearnableAttacks.Attacks[i];
604                LearnedAttacks.Add(LearnableAttacks.Attacks[i]);
605            }
606        }
607
608        for (int i = 0; i < LearnableSkills.Skills.Count; i++)
609        {
610            if (LearnableSkills.Skills[i].LearnAtLevel <= Level)
611            {
612                LearnedSkills.Add(LearnableSkills.Skills[i]);
613            }
614        }
615    }
616
617    #endregion
618}
Note: See TracBrowser for help on using the repository browser.