public static string GetName(SlimeType type)
{
switch (type)
{
case SlimeType.Green:
return("Green");
case SlimeType.Red:
return("Red");
case SlimeType.Blue:
return("Blue");
case SlimeType.Purple:
return("Purple");
case SlimeType.Black:
return("Black");
case SlimeType.White:
return("White");
case SlimeType.Gold:
return("Gold");
}
return("");
}
public static float GetExpMod(SlimeType type)
{
switch (type)
{
case SlimeType.Green:
return(1.0f);
case SlimeType.Red:
return(1.3f);
case SlimeType.Blue:
return(1.25f);
case SlimeType.Purple:
return(1.5f);
case SlimeType.Black:
return(3f);
case SlimeType.White:
return(3f);
case SlimeType.Gold:
return(10f);
}
return(1.0f);
}
public static Color GetColor(SlimeType type)
{
switch (type)
{
case SlimeType.Green:
return(new Color(0, 1, 76 / 255f));
case SlimeType.Red:
return(new Color(1, 0, 0));
case SlimeType.Blue:
return(new Color(0, 160 / 255f, 1f));
case SlimeType.Purple:
return(new Color(.5f, 0, 1.0f));
case SlimeType.Black:
float t = 86 / 255f;
return(new Color(t, t, t));
case SlimeType.White:
return(Color.white);
case SlimeType.Gold:
return(new Color(1, 215 / 255f, 0f));
}
return(Color.grey);
}
public void OnUnmerge(SlimeType type)
{
if (!type.IsKing())
{
stats.Unmerge(type);
}
}
void ActiveApowerUp(SlimeType slimeType)
{
switch (slimeType)
{
case SlimeType.Bomb:
break;
case SlimeType.Boss:
break;
case SlimeType.Heart:
break;
case SlimeType.Helmet:
break;
case SlimeType.Ice:
PowerupEnabled[1] = true;
PowerUpTimeLeft[1] += 5f;
break;
case SlimeType.Pinata:
break;
case SlimeType.Time:
PowerupEnabled[0] = true;
PowerUpTimeLeft[0] += 0.3f;
Debug.Log("frozenPickup");
break;
case SlimeType.Normal:
break;
}
}
public override bool CanInteract(PlayerUnitController controller)
{
PlayerBaseStats stats = controller.di.stats;
SlimeType type = stats.SlimeType;
bool isAssembly = stats.IsAssembly;
switch (interactionType)
{
case SlimeInteractionType.OnlyUnitNoAssembly:
return(!isAssembly && canInteract.Get(type));
case SlimeInteractionType.UnitOrUnitInAssembly:
return(canInteract.Get(type) || HasMergedAny(stats));
case SlimeInteractionType.UnitOrAnyInAssembly:
return(canInteract.Get(type) || isAssembly);
case SlimeInteractionType.OnlyUnitInAssembly:
return(canInteract.Get(type) && isAssembly);
case SlimeInteractionType.OnlyAllUnitsInAssembly:
return(isAssembly && HasMergedAll(stats));
}
return(false);
}
public SlimeData(SlimeType type, int size)
{
this.type = type;
this.size = size;
switch (type)
{
case SlimeType.BLUE: // is okay for up to maybe size 5?
this.scale = 1.0f;
this.moveSpeed = size > 1 ? 2f : 1.5f;
this.split = size > 1 ? 2 : 0;
break;
case SlimeType.RED: //best to have max size 2
this.scale = size > 1 ? 2.0f : 0.75f;
this.split = size > 1 ? 8 : 0;
this.moveSpeed = size > 1 ? 1.4f : 2.3f;
break;
default:
this.scale = 1.0f;
this.moveSpeed = 1.0f;
this.split = size > 1 ? 2 : 0;
break;
}
}
public void OnDeath(PlayerUnitController unit, Vector2 relictVelocity)
{
PlayerBaseStats stats = unit.di.stats;
SlimeType poofType = stats.SlimeType;
Vector2 spawnPosition = unit.transform.position;
SlimePoof slimePoof = poofs[poofType];
slimePoof.SpawnAt(spawnPosition);
foreach (SlimeType type in SlimeTypeHelpers.GetEnumerable())
{
if (stats.HasType(type))
{
SlimeRelict relict = relicts[type];
relict.SpawnAt(spawnPosition);
Vector2 velocity = GenerateRelictVelocity();
relict.SetVelocity(velocity);
relict.SetRotation(RandomHelpers.Range(relicRotationsPerSecond));
//relictVelocity = Vector2.zero;
}
}
}
public void ControlUpdate()
{
if (!stats.IsAssembly)
{
return;
}
if (input.yeet.IsPressed())
{
SlimeType selectedType = unitHandler.SelectedType;
if (selectedType.IsKing())
{
if (hp.IsFull())
{
PerformYeet(selectedType);
}
}
else
{
PlayerBaseStats unitStats = unitHandler.GetSelectable(selectedType).Stats;
int hearts = unitStats.Hearts;
if (hp.CurrentHP > hearts)
{
PerformYeet(selectedType);
}
}
}
}
private void PerformYeet(SlimeType selectedType)
{
input.yeet.Use();
unitHandler.OnSlimeYeet(selectedType);
stateMachine.SetInactiveState();
physics.velocity.Value = Vector2.zero;
}
private void AddStatsFrom(SlimeType type)
{
ScriptableSlime scriptableSlime = config.Data.Get(type);
strength += scriptableSlime.Strength;
hearts += scriptableSlime.Hearts;
}
public void Check()
{
int lastValue = 0;
int actualValue = 0;
SlimeType type = (SlimeType)System.Enum.Parse(typeof(SlimeType), "Water");
List <SlimeType> types = new List <SlimeType>();
for (int i = 0; i < answers.Count; i++)
{
for (int j = 0; j < answers[i].Types.Count; j++)
{
types.Add(answers[i].Types[j]);
}
}
/*for (int j = 0; j < types.Count; j++)
* {
* Debug.Log(types[j]);
* }*/
for (int i = 0; i < System.Enum.GetValues(typeof(SlimeType)).Length; i++)
{
//type = (SlimeType)i;
for (int j = 0; j < types.Count; j++)
{
// Debug.Log("son iguales " + ((SlimeType)i == (SlimeType)j));
//Debug.Log("son iguales " + (SlimeType)i + " == " + types[j]);
if ((SlimeType)i == types[j])
{
lastValue++;
}
if (lastValue > actualValue)
{
actualValue = lastValue;
Debug.Log((SlimeType)i);
type = (SlimeType)i;
Slime.GetComponent <Image>().sprite = sprites[(int)type];
}
}
lastValue = 0;
//Debug.Log("type" + type);
}
try
{
var data = DataManager.LoadData <Data>();
var acount = data.GetAcount(Globals.playerName);
acount.player.slimes.Add(new DataSystem.Slime("Slime " + type.ToString(), 250, 250, 100, type.ToString()));
DataManager.SaveData <Data>(data);
}
catch
{
Debug.Log("haaaaaa perro! no hay slimes wey");
}
Slime.transform.localScale = new Vector3(2f, 2.5f, 2f);
Slime.SetActive(true);
Empezar.gameObject.SetActive(true);
//Debug.Log(type.ToString());
}
public void YeetOutside(SlimeType type)
{
PlayerUnitSelectable selectable = unitHandler.GetSelectable(type);
selectable.UnitController.di.camera.CameraSegment = unitController.di.camera.CameraSegment;
selectable.GetYeeted(unitController.di.yeetModule);
selectable.SetActive();
}
public void OnActivate(SlimeType type)
{
wispRenderer.PlayIdle();
if (!segmentMember.Segment)
{
segmentMember.ManualCast();
}
}
public void ChangeType(SlimeType type)
{
EndDieAnimation();
ResetIdleAnimation();
_nowSelectedSlime.transform.rotation = _originRotation;
_nowSelectedSlime.SetActive(false);
_nowSlimeType = type;
CheckSlime();
}
public void LateInit(float mass, SlimeType type)
{
this.type = type;
weigth = mass;
this.basicAttack.damage = (int)(5 * weigth);
this.specialAttack.damage = (int)(10 * weigth);
maxLife = weigth * 10;
currentLife = maxLife;
}
public override void Unmerge(SlimeType type)
{
if (type.IsKing())
{
throw new Exception("Cannot Yeet King outside");
}
mergedSlimes.Set(type, false);
RecalculateState();
}
public override void MergeInside(SlimeType type)
{
if (type.IsKing())
{
throw new Exception("Cannot Merge King inside");
}
mergedSlimes.Set(type, true);
RecalculateState();
}
void Awake()
{
_slimeIndex = _colorIndex = 0;
_nowSlimeType = SlimeType.TYPE_A;
_nowSelectedSlime = _orgSlimeTypeA [_colorIndex];
_originRotation = _nowSelectedSlime.transform.rotation;
_nowSlimeIdleClipName = null;
_dieAnimationStete = DIE_ANIMATION_STATE.NONE;
CheckSlimeUI();
}
public RankingData()
{
objectId = "";
playerStatus = new PlayerStatus(false);
rankingName = "名無しのごんべえ";
slimeType = SlimeType.Normal;
arrivalStage = 1;
slimeNum = 0;
score = 0;
}
/// <summary>
/// Set the appropriate slime type for this slimeball
/// </summary>
/// <param name="type"></param>
public void SetSlimeType(SlimeType type)
{
slimeType = type;
Color c = PlayerController.gooColors[(int)slimeType];
GetComponent <SpriteRenderer>().color = c;
ParticleSystem.MainModule main = splashParticles.main;
main.startColor = c;
}
public Slime(EntityPreset preset, Player player)
: base(preset, preset.Position, "slime", 16, 16, DrawOrder.ENTITIES)
{
_type = preset.Frame == 3 ? SlimeType.Bullet : SlimeType.Normal;
int o = GlobalState.IsCell ? 4 : 0;
AddAnimation("Move", CreateAnimFrameArray(0 + o, 1 + o), 3);
AddAnimation("Hurt", CreateAnimFrameArray(0 + o, 8, 0 + o, 8), 15, false);
AddAnimation("Dying", CreateAnimFrameArray(0 + o, 8, 0 + o, 8), 12, false);
goos = new EntityPool <Goo>(8, () => new Goo());
target = player;
if (_type == SlimeType.Bullet)
{
bullets = new EntityPool <Bullet>(4, () => new Bullet());
_speed *= 2;
}
state = new StateMachineBuilder()
.State <MoveState>("Move")
.Enter((state) =>
{
Play("Move");
state.Advance((float)(DateTime.Now - state.exit_time).TotalSeconds);
if (_type == SlimeType.Bullet)
{
state.AddTimer(1.8f, "ShootTimer");
}
})
.Update((state, time) => SyncSplash(state))
.Event("ShootTimer", (state) => bullets.Spawn(b => b.Spawn(this, target)))
.Event("MoveTimer", (state) => ChangeDir())
.Event <CollisionEvent <Player> >("Player", (state, p) => p.entity.ReceiveDamage(1))
.Event <CollisionEvent <Broom> >("Hit", (state, b) => GetHit(b.entity))
.Exit((s) =>
{
s.exit_time = DateTime.Now;
})
.End()
.State("Hurt")
.Enter((state) => Play("Hurt"))
.Event <CollisionEvent <Player> >("Player", (state, p) => p.entity.ReceiveDamage(1))
.Condition(() => _health <= 0, (state) => state.Parent.ChangeState("Dying"))
.Condition(() => _curAnim.Finished, (state) => state.Parent.ChangeState("Move"))
.End()
.State("Dying")
.Enter((state) => Play("Dying"))
.Condition(() => _curAnim.Finished, (state) => { GlobalState.SpawnEntity(new Explosion(this)); Die(); })
.End()
.Build();
state.ChangeState("Move");
}
internal void HandleInput(SlimeType slime_type, int i, int j)
{
GameTile tile = Grid.GetTile(i, j);
if (tile == null)
{
return;
}
tile.HandleInput(slime_type);
}
public void CaptureObject(Transform obj)
{
Material[] innerMats = innerSlimeMesh.materials;
innerMats[0] = obj.GetComponentInParent <SlimeStateManager>().innerSlimeMaterial;
slimeMesh.material = obj.GetComponentInChildren <SkinnedMeshRenderer>().material;
capturedType = obj.GetComponentInParent <SlimeStateManager>().CaptureSlime();
innerSlimeMesh.materials = innerMats;
dummySlime.gameObject.SetActive(true);
hooked = true;
}
public void CheckForSlimeChange()
{
if (action.IsAttacking)
{
return;
}
if (input.selectSlime.IsPressed())
{
input.selectSlime.Use();
SlimeType pressedType = input.selectSlime.GetPressedSlime();
unitHandler.SelectSlime(pressedType);
}
}
public Slime(EntityPreset preset, Player player)
: base(preset.Position, "slime", 16, 16, DrawOrder.ENTITIES)
{
_preset = preset;
_type = _preset.Frame == 3 ? SlimeType.Bullet : SlimeType.Normal;
AddAnimation("Move", CreateAnimFrameArray(0, 1), 3);
AddAnimation("Hurt", CreateAnimFrameArray(0, 8, 0, 8), 15);
AddAnimation("Dying", CreateAnimFrameArray(0, 8, 0, 8), 12, false);
goos = new EntityPool <Goo>(8, () => new Goo());
target = player;
if (_type == SlimeType.Bullet)
{
bullets = new EntityPool <Bullet>(4, () => new Bullet());
_speed *= 2;
}
state = new StateMachineBuilder()
.State <MoveState>("Move")
.Enter((state) =>
{
Play("Move");
state.Reset();
state.AddTimer(0.5f, "MoveTimer");
if (_type == SlimeType.Bullet)
{
state.AddTimer(1.8f, "ShootTimer");
}
})
.Update((state, time) => SyncSplash(state))
.Event("ShootTimer", (state) => bullets.Spawn(b => b.Spawn(this, target)))
.Event("MoveTimer", (state) => ChangeDir())
.Event <CollisionEvent <Player> >("Player", (state, p) => p.entity.ReceiveDamage(1))
.Event <CollisionEvent <Broom> >("Hit", (state, b) => GetHit(b.entity))
.End()
.State("Hurt")
.Enter((state) => Play("Hurt"))
.Event <CollisionEvent <Player> >("Player", (state, p) => p.entity.ReceiveDamage(1))
.Condition(() => _health <= 0, (state) => state.Parent.ChangeState("Dying"))
.Condition(() => finished, (state) => state.Parent.ChangeState("Move"))
.End()
.State("Dying")
.Enter((state) => Play("Dying"))
.Condition(() => finished, (state) => { _preset.Alive = false; Die(); })
.End()
.Build();
state.ChangeState("Move");
}
public SlimeData(string type, int live, int maxLive, float mass)
{
foreach (SlimeType t in System.Enum.GetValues(typeof(SlimeType)))
{
if (t.ToString().Equals(type))
{
this.type = t;
break;
}
}
this.live = live;
this.maxLive = maxLive;
this.mass = mass;
}
public void UpdateAmmo(float newAmmo, SlimeType newType)
{
targetAmmo = newAmmo;
if (newType != type)
{
type = newType;
Color baseColor = slimeColors[(int)type];
Color foamColor = Color.Lerp(baseColor, Color.white, 0.5f);
liquidMaterial.SetColor("_Tint", baseColor);
liquidMaterial.SetColor("_TopColor", foamColor);
liquidMaterial.SetColor("_FoamColor", foamColor);
}
}
internal void SendInputData(SlimeType slimeType, int i, int j)
{
int other_player = PeerId == 1 ? 2 : 1;
int[] targets = new int[] { other_player };
RTData data = new RTData();
data.SetInt(3, (int)slimeType);
data.SetInt(1, i);
data.SetInt(2, j);
RtGS.SendData(1, GameSparksRT.DeliveryIntent.RELIABLE, data, targets);
}
public void OnSlimeYeet(SlimeType gotYeetd)
{
if (gotYeetd == SlimeType.King)
{
assemblySelectable.YeetKingOutside();
}
else
{
assemblySelectable.YeetOutsideAndDeselect(gotYeetd);
}
selectables.Get(gotYeetd).Select();
selectedType = gotYeetd;
OnMergeChange();
}
public SlimeInfo GetSlimeInfo(SlimeType type)
{
for (int i = 0; i < slimes.Length; i++)
{
if (slimes[i].slimeType == type)
{
return slimes[i];
}
}
if (slimes.Length < 1)
{
Debug.LogError("No Slimes In List!");
}
Debug.LogError("Slime Not Found!");
return slimes[0];
}
public void SetSlimeType(SlimeType type)
{
slimeType_ = type;
slimeInfo = ParentScrip._slimesList.GetSlimeInfo(type);
hp = slimeInfo.hP;
molePopupTime = slimeInfo.molePopupTime;
_GotSlime = true;
SlimeDead_ = false;
privateWaitTime = (1f / GameSettings.animationFPS * slimeInfo.frameCount);
GameObject newSlime = new GameObject("slime");
SpriteRenderer newSprite = newSlime.AddComponent<SpriteRenderer>();
newSprite.sprite = ParentScrip.initSprite;
newSprite.sortingOrder = orderLayer;
animator = newSlime.AddComponent<Animator>();
animator.runtimeAnimatorController = slimeInfo.runtimeAnimatorController;
newSlime.transform.parent = transform;
newSlime.transform.localPosition = OffSet;
}
void ActiveApowerUp(SlimeType slimeType)
{
switch (slimeType)
{
case SlimeType.Bomb:
break;
case SlimeType.Boss:
break;
case SlimeType.Heart:
break;
case SlimeType.Helmet:
break;
case SlimeType.Ice:
PowerupEnabled[1] = true;
PowerUpTimeLeft[1] += 5f;
break;
case SlimeType.Pinata:
break;
case SlimeType.Time:
PowerupEnabled[0] = true;
PowerUpTimeLeft[0] += 0.3f;
Debug.Log("frozenPickup");
break;
case SlimeType.Normal:
break;
}
}
